react-native-audio-api 0.11.0-alpha.0 → 0.11.0-alpha.10

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,9 +11,9 @@ 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
+  private var isTransientLoss: Boolean = false
 
   override fun onAudioFocusChange(focusChange: Int) {
     Log.d("AudioFocusListener", "onAudioFocusChange: $focusChange")
@@ -23,6 +23,7 @@ class AudioFocusListener(
           HashMap<String, Any>().apply {
             put("type", "began")
             put("shouldResume", false)
+            isTransientLoss = false
           }
         audioAPIModule.get()?.invokeHandlerWithEventNameAndEventBody("interruption", body)
       }
@@ -32,6 +33,7 @@ class AudioFocusListener(
           HashMap<String, Any>().apply {
             put("type", "began")
             put("shouldResume", false)
+            isTransientLoss = true
           }
         audioAPIModule.get()?.invokeHandlerWithEventNameAndEventBody("interruption", body)
       }
@@ -40,7 +42,8 @@ class AudioFocusListener(
         val body =
           HashMap<String, Any>().apply {
             put("type", "ended")
-            put("shouldResume", true)
+            put("shouldResume", isTransientLoss)
+            isTransientLoss = 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()
+  }
+}

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()
+      }
+    }
+  }
+}

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 {