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

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

@@ -4,13 +4,11 @@ import android.Manifest
 import android.app.NotificationChannel
 import android.app.NotificationManager
 import android.content.Context
-import android.content.Intent
 import android.content.IntentFilter
 import android.content.pm.PackageManager
 import android.media.AudioDeviceInfo
 import android.media.AudioManager
 import android.os.Build
-import android.support.v4.media.session.MediaSessionCompat
 import androidx.annotation.RequiresApi
 import androidx.core.app.NotificationCompat
 import androidx.core.content.ContextCompat
@@ -20,11 +18,14 @@ import com.facebook.react.bridge.ReadableMap
 import com.facebook.react.modules.core.PermissionAwareActivity
 import com.facebook.react.modules.core.PermissionListener
 import com.swmansion.audioapi.AudioAPIModule
-import com.swmansion.audioapi.core.NativeAudioPlayer
-import com.swmansion.audioapi.core.NativeAudioRecorder
 import com.swmansion.audioapi.system.PermissionRequestListener.Companion.RECORDING_REQUEST_CODE
+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 com.swmansion.audioapi.system.notification.RecordingNotificationReceiver
+import com.swmansion.audioapi.system.notification.SimpleNotification
 import java.lang.ref.WeakReference
-import java.util.UUID
 
 object MediaSessionManager {
   private lateinit var audioAPIModule: WeakReference<AudioAPIModule>
@@ -33,17 +34,13 @@ object MediaSessionManager {
   const val CHANNEL_ID = "react-native-audio-api"
 
   private lateinit var audioManager: AudioManager
-  private lateinit var mediaSession: MediaSessionCompat
-  lateinit var mediaNotificationManager: MediaNotificationManager
-  private lateinit var lockScreenManager: LockScreenManager
   private lateinit var audioFocusListener: AudioFocusListener
   private lateinit var volumeChangeListener: VolumeChangeListener
-  private lateinit var mediaReceiver: MediaReceiver
+  private lateinit var playbackNotificationReceiver: PlaybackNotificationReceiver
+  private lateinit var recordingNotificationReceiver: RecordingNotificationReceiver
 
-  private var isServiceRunning = false
-  private val serviceStateLock = Any()
-  private val nativeAudioPlayers = mutableMapOf<String, NativeAudioPlayer>()
-  private val nativeAudioRecorders = mutableMapOf<String, NativeAudioRecorder>()
+  // New notification system
+  private lateinit var notificationRegistry: NotificationRegistry
 
   fun initialize(
     audioAPIModule: WeakReference<AudioAPIModule>,
@@ -52,118 +49,54 @@ object MediaSessionManager {
     this.audioAPIModule = audioAPIModule
     this.reactContext = reactContext
     this.audioManager = reactContext.get()?.getSystemService(Context.AUDIO_SERVICE) as AudioManager
-    this.mediaSession = MediaSessionCompat(reactContext.get()!!, "MediaSessionManager")
+
+    // Initialize ForegroundServiceManager
+    ForegroundServiceManager.initialize(reactContext)
 
     if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
       createChannel()
     }
 
-    this.mediaNotificationManager = MediaNotificationManager(this.reactContext)
-    this.lockScreenManager = LockScreenManager(this.reactContext, WeakReference(this.mediaSession), WeakReference(mediaNotificationManager))
-    this.mediaReceiver =
-      MediaReceiver(this.reactContext, WeakReference(this.mediaSession), WeakReference(this.mediaNotificationManager), this.audioAPIModule)
-    this.mediaSession.setCallback(MediaSessionCallback(this.audioAPIModule, WeakReference(this.mediaNotificationManager)))
-
-    val filter = IntentFilter()
-    filter.addAction(MediaNotificationManager.REMOVE_NOTIFICATION)
-    filter.addAction(MediaNotificationManager.MEDIA_BUTTON)
-    filter.addAction(Intent.ACTION_MEDIA_BUTTON)
-    filter.addAction(AudioManager.ACTION_AUDIO_BECOMING_NOISY)
+    // Set up PlaybackNotificationReceiver
+    PlaybackNotificationReceiver.setAudioAPIModule(audioAPIModule.get())
+    this.playbackNotificationReceiver = PlaybackNotificationReceiver()
 
+    // Register PlaybackNotificationReceiver
+    val playbackFilter = IntentFilter(PlaybackNotificationReceiver.ACTION_NOTIFICATION_DISMISSED)
     if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
-      this.reactContext.get()!!.registerReceiver(mediaReceiver, filter, Context.RECEIVER_EXPORTED)
+      this.reactContext.get()!!.registerReceiver(playbackNotificationReceiver, playbackFilter, Context.RECEIVER_NOT_EXPORTED)
     } else {
       ContextCompat.registerReceiver(
         this.reactContext.get()!!,
-        mediaReceiver,
-        filter,
+        playbackNotificationReceiver,
+        playbackFilter,
         ContextCompat.RECEIVER_NOT_EXPORTED,
       )
     }
 
-    this.audioFocusListener =
-      AudioFocusListener(WeakReference(this.audioManager), this.audioAPIModule, WeakReference(this.lockScreenManager))
-    this.volumeChangeListener = VolumeChangeListener(WeakReference(this.audioManager), this.audioAPIModule)
-  }
-
-  fun attachAudioPlayer(player: NativeAudioPlayer): String {
-    val uuid = UUID.randomUUID().toString()
-    nativeAudioPlayers[uuid] = player
-
-    return uuid
-  }
-
-  fun detachAudioPlayer(uuid: String) {
-    nativeAudioPlayers.remove(uuid)
-  }
+    // Set up RecordingNotificationReceiver
+    RecordingNotificationReceiver.setAudioAPIModule(audioAPIModule.get())
+    this.recordingNotificationReceiver = RecordingNotificationReceiver()
 
-  fun attachAudioRecorder(recorder: NativeAudioRecorder): String {
-    val uuid = UUID.randomUUID().toString()
-    nativeAudioRecorders[uuid] = recorder
-
-    return uuid
-  }
-
-  fun detachAudioRecorder(uuid: String) {
-    nativeAudioRecorders.remove(uuid)
-  }
-
-  fun startForegroundServiceIfNecessary() {
-    if (nativeAudioPlayers.isNotEmpty() || nativeAudioRecorders.isNotEmpty()) {
-      startForegroundService()
-    }
-  }
-
-  fun stopForegroundServiceIfNecessary() {
-    if (nativeAudioPlayers.isEmpty() && nativeAudioRecorders.isEmpty()) {
-      stopForegroundService()
-    }
-  }
-
-  private fun startForegroundService() {
-    synchronized(serviceStateLock) {
-      if (isServiceRunning || reactContext.get() == null) {
-        return
-      }
-
-      val intent = Intent(reactContext.get(), MediaNotificationManager.AudioForegroundService::class.java)
-      intent.action = MediaNotificationManager.ForegroundAction.START_FOREGROUND.name
-
-      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-        ContextCompat.startForegroundService(reactContext.get()!!, intent)
-      } else {
-        reactContext.get()!!.startService(intent)
-      }
-      isServiceRunning = true
+    // Register RecordingNotificationReceiver
+    val recordingFilter = IntentFilter(RecordingNotificationReceiver.ACTION_NOTIFICATION_DISMISSED)
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+      this.reactContext.get()!!.registerReceiver(recordingNotificationReceiver, recordingFilter, Context.RECEIVER_NOT_EXPORTED)
+    } else {
+      ContextCompat.registerReceiver(
+        this.reactContext.get()!!,
+        recordingNotificationReceiver,
+        recordingFilter,
+        ContextCompat.RECEIVER_NOT_EXPORTED,
+      )
     }
-  }
 
-  private fun stopForegroundService() {
-    synchronized(serviceStateLock) {
-      if (!isServiceRunning || reactContext.get() == null) {
-        return
-      }
-
-      val intent = Intent(reactContext.get(), MediaNotificationManager.AudioForegroundService::class.java)
-      intent.action = MediaNotificationManager.ForegroundAction.STOP_FOREGROUND.name
-      reactContext.get()!!.startService(intent)
-      isServiceRunning = false
-    }
-  }
-
-  fun setLockScreenInfo(info: ReadableMap?) {
-    lockScreenManager.setLockScreenInfo(info)
-  }
-
-  fun resetLockScreenInfo() {
-    lockScreenManager.resetLockScreenInfo()
-  }
+    this.audioFocusListener =
+      AudioFocusListener(WeakReference(this.audioManager), this.audioAPIModule)
+    this.volumeChangeListener = VolumeChangeListener(WeakReference(this.audioManager), this.audioAPIModule)
 
-  fun enableRemoteCommand(
-    name: String,
-    enabled: Boolean,
-  ) {
-    lockScreenManager.enableRemoteCommand(name, enabled)
+    // Initialize new notification system
+    this.notificationRegistry = NotificationRegistry(this.reactContext)
   }
 
   fun getDevicePreferredSampleRate(): Double {
@@ -211,6 +144,41 @@ object MediaSessionManager {
       "Denied"
     }
 
+  fun requestNotificationPermissions(permissionListener: PermissionListener) {
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+      val permissionAwareActivity = reactContext.get()!!.currentActivity as PermissionAwareActivity
+      permissionAwareActivity.requestPermissions(
+        arrayOf(Manifest.permission.POST_NOTIFICATIONS),
+        PermissionRequestListener.NOTIFICATION_REQUEST_CODE,
+        permissionListener,
+      )
+    } else {
+      // For Android < 13, permission is granted by default
+      val result = Arguments.createMap()
+      result.putString("status", "Granted")
+      permissionListener.onRequestPermissionsResult(
+        PermissionRequestListener.NOTIFICATION_REQUEST_CODE,
+        arrayOf(Manifest.permission.POST_NOTIFICATIONS),
+        intArrayOf(PackageManager.PERMISSION_GRANTED),
+      )
+    }
+  }
+
+  fun checkNotificationPermissions(): String {
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+      return if (reactContext.get()!!.checkSelfPermission(
+          Manifest.permission.POST_NOTIFICATIONS,
+        ) == PackageManager.PERMISSION_GRANTED
+      ) {
+        "Granted"
+      } else {
+        "Denied"
+      }
+    }
+    // For Android < 13, permission is granted by default
+    return "Granted"
+  }
+
   @RequiresApi(Build.VERSION_CODES.O)
   private fun createChannel() {
     val notificationManager =
@@ -267,4 +235,44 @@ object MediaSessionManager {
       AudioDeviceInfo.TYPE_BLUETOOTH_SCO -> "Bluetooth SCO"
       else -> "Other (${device.type})"
     }
+
+  // New notification system methods
+  fun registerNotification(
+    type: String,
+    key: String,
+  ) {
+    val notification =
+      when (type) {
+        "simple" -> SimpleNotification(reactContext)
+        "playback" -> PlaybackNotification(reactContext, audioAPIModule, 100, "audio_playback")
+        "recording" -> RecordingNotification(reactContext, audioAPIModule, 101, "audio_recording23")
+        else -> throw IllegalArgumentException("Unknown notification type: $type")
+      }
+
+    notificationRegistry.registerNotification(key, notification)
+  }
+
+  fun showNotification(
+    key: String,
+    options: ReadableMap?,
+  ) {
+    notificationRegistry.showNotification(key, options)
+  }
+
+  fun updateNotification(
+    key: String,
+    options: ReadableMap?,
+  ) {
+    notificationRegistry.updateNotification(key, options)
+  }
+
+  fun hideNotification(key: String) {
+    notificationRegistry.hideNotification(key)
+  }
+
+  fun unregisterNotification(key: String) {
+    notificationRegistry.unregisterNotification(key)
+  }
+
+  fun isNotificationActive(key: String): Boolean = notificationRegistry.isNotificationActive(key)
 }

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

@@ -9,6 +9,7 @@ class PermissionRequestListener(
 ) : PermissionListener {
   companion object {
     const val RECORDING_REQUEST_CODE = 1234
+    const val NOTIFICATION_REQUEST_CODE = 1235
   }
 
   override fun onRequestPermissionsResult(
@@ -16,7 +17,7 @@ class PermissionRequestListener(
     permissions: Array<String>,
     grantResults: IntArray,
   ): Boolean {
-    if (requestCode == RECORDING_REQUEST_CODE) {
+    if (requestCode == RECORDING_REQUEST_CODE || requestCode == NOTIFICATION_REQUEST_CODE) {
       if (grantResults.isEmpty()) {
         this.promise.resolve("Undetermined")
       } else {

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

@@ -0,0 +1,47 @@
+package com.swmansion.audioapi.system.notification
+
+import android.app.Notification
+import com.facebook.react.bridge.ReadableMap
+
+/**
+ * Base interface for all notification types.
+ * Implementations should handle their own notification channel creation,
+ * notification building, and lifecycle management.
+ */
+interface BaseNotification {
+  /**
+   * Initialize the notification with the provided options.
+   * This method should create the notification and prepare it for display.
+   *
+   * @param options Configuration options from JavaScript side
+   * @return The built Notification ready to be shown
+   */
+  fun init(options: ReadableMap?): Notification
+
+  /**
+   * Update the notification with new options.
+   * This method should rebuild the notification with updated data.
+   *
+   * @param options New configuration options from JavaScript side
+   * @return The updated Notification ready to be shown
+   */
+  fun update(options: ReadableMap?): Notification
+
+  /**
+   * Reset the notification to its initial state.
+   * This should clear any stored data and stop any ongoing processes.
+   */
+  fun reset()
+
+  /**
+   * Get the unique ID for this notification.
+   * Used by the NotificationManager to track and manage notifications.
+   */
+  fun getNotificationId(): Int
+
+  /**
+   * Get the channel ID for this notification.
+   * Required for Android O+ notification channels.
+   */
+  fun getChannelId(): String
+}

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

@@ -0,0 +1,191 @@
+package com.swmansion.audioapi.system.notification
+
+import android.app.Notification
+import android.util.Log
+import androidx.core.app.NotificationManagerCompat
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableMap
+import com.swmansion.audioapi.system.ForegroundServiceManager
+import java.lang.ref.WeakReference
+
+/**
+ * Central notification registry that manages multiple notification instances.
+ */
+class NotificationRegistry(
+  private val reactContext: WeakReference<ReactApplicationContext>,
+) {
+  companion object {
+    private const val TAG = "NotificationRegistry"
+
+    // Store last built notifications for foreground service access
+    private val builtNotifications = mutableMapOf<Int, Notification>()
+
+    fun getBuiltNotification(notificationId: Int): Notification? = builtNotifications[notificationId]
+  }
+
+  private val notifications = mutableMapOf<String, BaseNotification>()
+  private val activeNotifications = mutableMapOf<String, Boolean>()
+
+  /**
+   * Register a new notification instance.
+   *
+   * @param key Unique identifier for this notification
+   * @param notification The notification instance to register
+   */
+  fun registerNotification(
+    key: String,
+    notification: BaseNotification,
+  ) {
+    notifications[key] = notification
+    Log.d(TAG, "Registered notification: $key")
+  }
+
+  /**
+   * Initialize and show a notification.
+   *
+   * @param key The unique identifier of the notification
+   * @param options Configuration options from JavaScript
+   */
+  fun showNotification(
+    key: String,
+    options: ReadableMap?,
+  ) {
+    val notification = notifications[key]
+    if (notification == null) {
+      Log.w(TAG, "Notification not found: $key")
+      return
+    }
+
+    try {
+      val builtNotification = notification.init(options)
+      displayNotification(notification.getNotificationId(), builtNotification)
+      activeNotifications[key] = true
+
+      // Subscribe to foreground service for persistent notifications
+      ForegroundServiceManager.subscribe("notification_$key")
+
+      Log.d(TAG, "Showing notification: $key")
+    } catch (e: Exception) {
+      Log.e(TAG, "Error showing notification $key: ${e.message}", e)
+    }
+  }
+
+  /**
+   * Update an existing notification with new options.
+   *
+   * @param key The unique identifier of the notification
+   * @param options New configuration options from JavaScript
+   */
+  fun updateNotification(
+    key: String,
+    options: ReadableMap?,
+  ) {
+    if (!activeNotifications.getOrDefault(key, false)) {
+      Log.w(TAG, "Cannot update inactive notification: $key")
+      return
+    }
+
+    val notification = notifications[key]
+    if (notification == null) {
+      Log.w(TAG, "Notification not found: $key")
+      return
+    }
+
+    try {
+      val builtNotification = notification.update(options)
+      displayNotification(notification.getNotificationId(), builtNotification)
+      Log.d(TAG, "Updated notification: $key")
+    } catch (e: Exception) {
+      Log.e(TAG, "Error updating notification $key: ${e.message}", e)
+    }
+  }
+
+  /**
+   * Hide and reset a notification.
+   *
+   * @param key The unique identifier of the notification
+   */
+  fun hideNotification(key: String) {
+    val notification = notifications[key]
+    if (notification == null) {
+      Log.w(TAG, "Notification not found: $key")
+      return
+    }
+
+    try {
+      cancelNotification(notification.getNotificationId())
+      notification.reset()
+      activeNotifications[key] = false
+
+      // Unsubscribe from foreground service
+      ForegroundServiceManager.unsubscribe("notification_$key")
+
+      Log.d(TAG, "Hiding notification: $key")
+    } catch (e: Exception) {
+      Log.e(TAG, "Error hiding notification $key: ${e.message}", e)
+    }
+  }
+
+  /**
+   * Unregister and cleanup a notification.
+   *
+   * @param key The unique identifier of the notification
+   */
+  fun unregisterNotification(key: String) {
+    hideNotification(key)
+    notifications.remove(key)
+    activeNotifications.remove(key)
+    Log.d(TAG, "Unregistered notification: $key")
+  }
+
+  /**
+   * Check if a notification is currently active.
+   */
+  fun isNotificationActive(key: String): Boolean = activeNotifications.getOrDefault(key, false)
+
+  /**
+   * Get all registered notification keys.
+   */
+  fun getRegisteredKeys(): Set<String> = notifications.keys.toSet()
+
+  /**
+   * Cleanup all notifications.
+   */
+  fun cleanup() {
+    notifications.keys.toList().forEach { key ->
+      hideNotification(key)
+    }
+    notifications.clear()
+    activeNotifications.clear()
+    builtNotifications.clear()
+
+    // Cleanup foreground service manager
+    ForegroundServiceManager.cleanup()
+
+    Log.d(TAG, "Cleaned up all notifications")
+  }
+
+  private fun displayNotification(
+    id: Int,
+    notification: Notification,
+  ) {
+    val context = reactContext.get() ?: throw IllegalStateException("React context is null")
+    Log.d(TAG, "Displaying notification with ID: $id")
+    try {
+      // Store notification for foreground service access
+      builtNotifications[id] = notification
+
+      NotificationManagerCompat.from(context).notify(id, notification)
+      Log.d(TAG, "Notification posted successfully with ID: $id")
+    } catch (e: Exception) {
+      Log.e(TAG, "Error posting notification: ${e.message}", e)
+    }
+  }
+
+  private fun cancelNotification(id: Int) {
+    val context = reactContext.get() ?: return
+    NotificationManagerCompat.from(context).cancel(id)
+    // Clean up stored notification
+    builtNotifications.remove(id)
+  }
+}