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

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

@@ -0,0 +1,303 @@
+package com.swmansion.audioapi.system.notification
+
+import android.app.Notification
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.app.PendingIntent
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.graphics.Color
+import android.os.Build
+import android.util.Log
+import androidx.core.app.NotificationCompat
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableMap
+import com.swmansion.audioapi.AudioAPIModule
+import java.lang.ref.WeakReference
+
+/**
+ * RecordingNotification
+ *
+ * Simple notification for audio recording:
+ * - Shows recording status with red background when recording
+ * - Simple start/stop button with microphone icon
+ * - Is persistent and cannot be swiped away when recording
+ * - Notifies its dismissal via RecordingNotificationReceiver
+ */
+class RecordingNotification(
+  private val reactContext: WeakReference<ReactApplicationContext>,
+  private val audioAPIModule: WeakReference<AudioAPIModule>,
+  private val notificationId: Int,
+  private val channelId: String,
+) : BaseNotification {
+  companion object {
+    private const val TAG = "RecordingNotification"
+    const val ACTION_START = "com.swmansion.audioapi.RECORDING_START"
+    const val ACTION_STOP = "com.swmansion.audioapi.RECORDING_STOP"
+  }
+
+  private var notificationBuilder: NotificationCompat.Builder? = null
+  private var isRecording: Boolean = false
+  private var title: String = "Audio Recording"
+  private var description: String = "Ready to record"
+  private var receiver: RecordingNotificationReceiver? = null
+  private var startEnabled: Boolean = true
+  private var stopEnabled: Boolean = true
+
+  override fun init(params: ReadableMap?): Notification {
+    val context = reactContext.get() ?: throw IllegalStateException("React context is null")
+
+    // Register broadcast receiver
+    registerReceiver()
+
+    // Create notification channel first
+    createNotificationChannel()
+
+    // Create notification builder
+    notificationBuilder =
+      NotificationCompat
+        .Builder(context, channelId)
+        .setSmallIcon(android.R.drawable.ic_btn_speak_now)
+        .setContentTitle(title)
+        .setContentText(description)
+        .setPriority(NotificationCompat.PRIORITY_HIGH)
+        .setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
+        .setOngoing(false)
+        .setAutoCancel(false)
+
+    // Set content intent to open app
+    val packageName = context.packageName
+    val openAppIntent = context.packageManager.getLaunchIntentForPackage(packageName)
+    if (openAppIntent != null) {
+      val pendingIntent =
+        PendingIntent.getActivity(
+          context,
+          0,
+          openAppIntent,
+          PendingIntent.FLAG_IMMUTABLE,
+        )
+      notificationBuilder?.setContentIntent(pendingIntent)
+    }
+
+    // Set delete intent to handle dismissal
+    val deleteIntent = Intent(RecordingNotificationReceiver.ACTION_NOTIFICATION_DISMISSED)
+    deleteIntent.setPackage(context.packageName)
+    val deletePendingIntent =
+      PendingIntent.getBroadcast(
+        context,
+        notificationId,
+        deleteIntent,
+        PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT,
+      )
+    notificationBuilder?.setDeleteIntent(deletePendingIntent)
+
+    // Apply initial params if provided
+    if (params != null) {
+      update(params)
+    }
+
+    return buildNotification()
+  }
+
+  override fun reset() {
+    // Unregister receiver
+    unregisterReceiver()
+
+    // Reset state
+    title = "Audio Recording"
+    description = "Ready to record"
+    isRecording = false
+    notificationBuilder = null
+  }
+
+  override fun getNotificationId(): Int = notificationId
+
+  override fun getChannelId(): String = channelId
+
+  override fun update(options: ReadableMap?): Notification {
+    if (options == null) {
+      return buildNotification()
+    }
+
+    // Handle control enable/disable
+    if (options.hasKey("control") && options.hasKey("enabled")) {
+      val control = options.getString("control")
+      val enabled = options.getBoolean("enabled")
+      when (control) {
+        "start" -> startEnabled = enabled
+        "stop" -> stopEnabled = enabled
+      }
+      updateActions()
+      return buildNotification()
+    }
+
+    // Update metadata
+    if (options.hasKey("title")) {
+      title = options.getString("title") ?: "Audio Recording"
+    }
+
+    if (options.hasKey("description")) {
+      description = options.getString("description") ?: "Ready to record"
+    }
+
+    // Update recording state
+    if (options.hasKey("state")) {
+      when (options.getString("state")) {
+        "recording" -> isRecording = true
+        "stopped" -> isRecording = false
+      }
+    }
+
+    // Update notification content
+    val statusText =
+      description.ifEmpty {
+        if (isRecording) "Recording..." else "Ready to record"
+      }
+    notificationBuilder
+      ?.setContentTitle(title)
+      ?.setContentText(statusText)
+      ?.setOngoing(isRecording)
+
+    // Set red color when recording
+    if (isRecording) {
+      notificationBuilder
+        ?.setColor(Color.RED)
+        ?.setColorized(true)
+    } else {
+      notificationBuilder
+        ?.setColorized(false)
+    }
+
+    // Update action button
+    updateActions()
+
+    return buildNotification()
+  }
+
+  private fun buildNotification(): Notification =
+    notificationBuilder?.build()
+      ?: throw IllegalStateException("Notification not initialized. Call init() first.")
+
+  private fun updateActions() {
+    val context = reactContext.get() ?: return
+
+    // Clear existing actions
+    notificationBuilder?.clearActions()
+
+    // Add appropriate action based on recording state and enabled controls
+    // Note: Android shows text labels in collapsed view, icons only in expanded/Auto/Wear
+    if (isRecording && stopEnabled) {
+      // Show STOP button when recording
+      val stopIntent = Intent(ACTION_STOP)
+      stopIntent.setPackage(context.packageName)
+      val stopPendingIntent =
+        PendingIntent.getBroadcast(
+          context,
+          1001,
+          stopIntent,
+          PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT,
+        )
+      val stopAction =
+        NotificationCompat.Action
+          .Builder(
+            android.R.drawable.ic_delete,
+            "Stop",
+            stopPendingIntent,
+          ).build()
+      notificationBuilder?.addAction(stopAction)
+    } else if (!isRecording && startEnabled) {
+      // Show START button when not recording
+      val startIntent = Intent(ACTION_START)
+      startIntent.setPackage(context.packageName)
+      val startPendingIntent =
+        PendingIntent.getBroadcast(
+          context,
+          1000,
+          startIntent,
+          PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT,
+        )
+      val startAction =
+        NotificationCompat.Action
+          .Builder(
+            android.R.drawable.ic_btn_speak_now,
+            "Record",
+            startPendingIntent,
+          ).build()
+      notificationBuilder?.addAction(startAction)
+    }
+
+    // Use BigTextStyle to ensure actions are visible
+    val statusText =
+      description.ifEmpty {
+        if (isRecording) "Recording in progress..." else "Ready to record"
+      }
+    notificationBuilder?.setStyle(
+      NotificationCompat
+        .BigTextStyle()
+        .bigText(statusText),
+    )
+  }
+
+  private fun createNotificationChannel() {
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+      val context = reactContext.get() ?: return
+
+      val channel =
+        NotificationChannel(
+          channelId,
+          "Audio Recording",
+          NotificationManager.IMPORTANCE_HIGH,
+        ).apply {
+          description = "Recording controls and status"
+          setShowBadge(true)
+          lockscreenVisibility = Notification.VISIBILITY_PUBLIC
+          enableLights(true)
+          lightColor = Color.RED
+          enableVibration(false)
+        }
+
+      val notificationManager =
+        context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+      notificationManager.createNotificationChannel(channel)
+
+      Log.d(TAG, "Notification channel created: $channelId")
+    }
+  }
+
+  private fun registerReceiver() {
+    val context = reactContext.get() ?: return
+
+    if (receiver == null) {
+      receiver = RecordingNotificationReceiver()
+      RecordingNotificationReceiver.setAudioAPIModule(audioAPIModule.get())
+
+      val filter = IntentFilter()
+      filter.addAction(ACTION_START)
+      filter.addAction(ACTION_STOP)
+      filter.addAction(RecordingNotificationReceiver.ACTION_NOTIFICATION_DISMISSED)
+
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+        context.registerReceiver(receiver, filter, Context.RECEIVER_NOT_EXPORTED)
+      } else {
+        context.registerReceiver(receiver, filter)
+      }
+
+      Log.d(TAG, "RecordingNotificationReceiver registered")
+    }
+  }
+
+  private fun unregisterReceiver() {
+    val context = reactContext.get() ?: return
+
+    receiver?.let {
+      try {
+        context.unregisterReceiver(it)
+        receiver = null
+        Log.d(TAG, "RecordingNotificationReceiver unregistered")
+      } catch (e: Exception) {
+        Log.e(TAG, "Error unregistering receiver: ${e.message}", e)
+      }
+    }
+  }
+}

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

@@ -0,0 +1,43 @@
+package com.swmansion.audioapi.system.notification
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.util.Log
+import com.swmansion.audioapi.AudioAPIModule
+
+/**
+ * Broadcast receiver for handling recording notification actions and dismissal.
+ */
+class RecordingNotificationReceiver : BroadcastReceiver() {
+  companion object {
+    const val ACTION_NOTIFICATION_DISMISSED = "com.swmansion.audioapi.RECORDING_NOTIFICATION_DISMISSED"
+    private const val TAG = "RecordingNotificationReceiver"
+
+    private var audioAPIModule: AudioAPIModule? = null
+
+    fun setAudioAPIModule(module: AudioAPIModule?) {
+      audioAPIModule = module
+    }
+  }
+
+  override fun onReceive(
+    context: Context?,
+    intent: Intent?,
+  ) {
+    when (intent?.action) {
+      ACTION_NOTIFICATION_DISMISSED -> {
+        Log.d(TAG, "Recording notification dismissed by user")
+        audioAPIModule?.invokeHandlerWithEventNameAndEventBody("recordingNotificationDismissed", mapOf())
+      }
+      RecordingNotification.ACTION_START -> {
+        Log.d(TAG, "Start recording action received")
+        audioAPIModule?.invokeHandlerWithEventNameAndEventBody("recordingNotificationStart", mapOf())
+      }
+      RecordingNotification.ACTION_STOP -> {
+        Log.d(TAG, "Stop recording action received")
+        audioAPIModule?.invokeHandlerWithEventNameAndEventBody("recordingNotificationStop", mapOf())
+      }
+    }
+  }
+}

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

@@ -0,0 +1,119 @@
+package com.swmansion.audioapi.system.notification
+
+import android.app.Notification
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.app.PendingIntent
+import android.content.Context
+import android.os.Build
+import androidx.core.app.NotificationCompat
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableMap
+import com.swmansion.audioapi.R
+import java.lang.ref.WeakReference
+
+/**
+ * This serves as a reference implementation and starting point for more complex notifications.
+ */
+class SimpleNotification(
+  private val reactContext: WeakReference<ReactApplicationContext>,
+  private val notificationId: Int = DEFAULT_NOTIFICATION_ID,
+) : BaseNotification {
+  companion object {
+    const val DEFAULT_NOTIFICATION_ID = 200
+    const val CHANNEL_ID = "react-native-audio-api-simple"
+    const val CHANNEL_NAME = "Simple Notifications"
+  }
+
+  private var title: String = "Audio Playing"
+  private var text: String = ""
+
+  init {
+    createNotificationChannel()
+  }
+
+  override fun init(options: ReadableMap?): Notification {
+    // Parse options from JavaScript
+    if (options != null) {
+      if (options.hasKey("title")) {
+        title = options.getString("title") ?: "Audio Playing"
+      }
+      if (options.hasKey("text")) {
+        text = options.getString("text") ?: ""
+      }
+    }
+
+    return buildNotification()
+  }
+
+  override fun update(options: ReadableMap?): Notification {
+    // Update works the same as init for simple notifications
+    return init(options)
+  }
+
+  override fun reset() {
+    // Reset to default values
+    title = "Audio Playing"
+    text = ""
+  }
+
+  override fun getNotificationId(): Int = notificationId
+
+  override fun getChannelId(): String = CHANNEL_ID
+
+  private fun buildNotification(): Notification {
+    val context = reactContext.get() ?: throw IllegalStateException("React context is null")
+
+    // Use a system icon that's guaranteed to exist
+    val icon = android.R.drawable.ic_dialog_info
+
+    val builder =
+      NotificationCompat
+        .Builder(context, CHANNEL_ID)
+        .setContentTitle(title)
+        .setContentText(text)
+        .setSmallIcon(icon)
+        .setPriority(NotificationCompat.PRIORITY_HIGH)
+        .setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
+        .setOngoing(false)
+        .setAutoCancel(false)
+
+    // Add content intent to open the app when notification is tapped
+    val packageName = context.packageName
+    val openAppIntent = context.packageManager?.getLaunchIntentForPackage(packageName)
+    if (openAppIntent != null) {
+      val pendingIntent =
+        PendingIntent.getActivity(
+          context,
+          0,
+          openAppIntent,
+          PendingIntent.FLAG_IMMUTABLE,
+        )
+      builder.setContentIntent(pendingIntent)
+    }
+
+    return builder.build()
+  }
+
+  private fun createNotificationChannel() {
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+      val context = reactContext.get() ?: return
+      val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+
+      val channel =
+        NotificationChannel(
+          CHANNEL_ID,
+          CHANNEL_NAME,
+          NotificationManager.IMPORTANCE_HIGH,
+        ).apply {
+          description = "Simple notification channel for audio playback"
+          setShowBadge(true)
+          lockscreenVisibility = Notification.VISIBILITY_PUBLIC
+          enableLights(true)
+          enableVibration(false)
+        }
+
+      notificationManager.createNotificationChannel(channel)
+    }
+  }
+}

package/ios/audioapi/ios/AudioAPIModule.h

@@ -11,7 +11,7 @@
 @class AudioEngine;
 @class NotificationManager;
 @class AudioSessionManager;
-@class LockScreenManager;
+@class NotificationRegistry;
 
 @interface AudioAPIModule : RCTEventEmitter
 #ifdef RCT_NEW_ARCH_ENABLED
@@ -23,7 +23,7 @@
 @property (nonatomic, strong) AudioEngine *audioEngine;
 @property (nonatomic, strong) NotificationManager *notificationManager;
 @property (nonatomic, strong) AudioSessionManager *audioSessionManager;
-@property (nonatomic, strong) LockScreenManager *lockScreenManager;
+@property (nonatomic, strong) NotificationRegistry *notificationRegistry;
 
 - (void)invokeHandlerWithEventName:(NSString *)eventName eventBody:(NSDictionary *)eventBody;
 

package/ios/audioapi/ios/AudioAPIModule.mm

@@ -11,8 +11,8 @@
 #import <audioapi/AudioAPIModuleInstaller.h>
 #import <audioapi/ios/system/AudioEngine.h>
 #import <audioapi/ios/system/AudioSessionManager.h>
-#import <audioapi/ios/system/LockScreenManager.h>
 #import <audioapi/ios/system/NotificationManager.h>
+#import <audioapi/ios/system/notification/NotificationRegistry.h>
 
 #import <audioapi/events/AudioEventHandlerRegistry.h>
 
@@ -50,7 +50,7 @@ RCT_EXPORT_MODULE(AudioAPIModule);
   [self.audioEngine cleanup];
   [self.notificationManager cleanup];
   [self.audioSessionManager cleanup];
-  [self.lockScreenManager cleanup];
+  [self.notificationRegistry cleanup];
 
   _eventHandler = nullptr;
 
@@ -61,8 +61,8 @@ RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(install)
 {
   self.audioSessionManager = [[AudioSessionManager alloc] init];
   self.audioEngine = [[AudioEngine alloc] initWithAudioSessionManager:self.audioSessionManager];
-  self.lockScreenManager = [[LockScreenManager alloc] initWithAudioAPIModule:self];
   self.notificationManager = [[NotificationManager alloc] initWithAudioAPIModule:self];
+  self.notificationRegistry = [[NotificationRegistry alloc] initWithAudioAPIModule:self];
 
   auto jsiRuntime = reinterpret_cast<facebook::jsi::Runtime *>(self.bridge.runtime);
 
@@ -142,21 +142,6 @@ RCT_EXPORT_METHOD(
                                       allowHaptics:allowHaptics];
 }
 
-RCT_EXPORT_METHOD(setLockScreenInfo : (NSDictionary *)info)
-{
-  [self.lockScreenManager setLockScreenInfo:info];
-}
-
-RCT_EXPORT_METHOD(resetLockScreenInfo)
-{
-  [self.lockScreenManager resetLockScreenInfo];
-}
-
-RCT_EXPORT_METHOD(enableRemoteCommand : (NSString *)name enabled : (BOOL)enabled)
-{
-  [self.lockScreenManager enableRemoteCommand:name enabled:enabled];
-}
-
 RCT_EXPORT_METHOD(observeAudioInterruptions : (BOOL)enabled)
 {
   [self.notificationManager observeAudioInterruptions:enabled];
@@ -190,6 +175,25 @@ RCT_EXPORT_METHOD(
   });
 }
 
+RCT_EXPORT_METHOD(
+    requestNotificationPermissions : (nonnull RCTPromiseResolveBlock)
+        resolve reject : (nonnull RCTPromiseRejectBlock)reject)
+{
+  // iOS doesn't require explicit notification permissions for media controls
+  // MPNowPlayingInfoCenter and MPRemoteCommandCenter work without permissions
+  // Return 'granted' to match the spec interface
+  resolve(@"granted");
+}
+
+RCT_EXPORT_METHOD(
+    checkNotificationPermissions : (nonnull RCTPromiseResolveBlock)
+        resolve reject : (nonnull RCTPromiseRejectBlock)reject)
+{
+  // iOS doesn't require explicit notification permissions for media controls
+  // Return 'granted' to match the spec interface
+  resolve(@"granted");
+}
+
 RCT_EXPORT_METHOD(
     getDevicesInfo : (nonnull RCTPromiseResolveBlock)
         resolve reject : (nonnull RCTPromiseRejectBlock)reject)
@@ -204,6 +208,92 @@ RCT_EXPORT_METHOD(disableSessionManagement)
   [self.audioSessionManager disableSessionManagement];
 }
 
+// New notification system methods
+RCT_EXPORT_METHOD(
+    registerNotification : (NSString *)type key : (NSString *)key resolve : (RCTPromiseResolveBlock)
+        resolve reject : (RCTPromiseRejectBlock)reject)
+{
+  dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+    BOOL success = [self.notificationRegistry registerNotificationType:type withKey:key];
+
+    if (success) {
+      resolve(@{@"success" : @true});
+    } else {
+      resolve(@{@"success" : @false, @"error" : @"Failed to register notification"});
+    }
+  });
+}
+
+RCT_EXPORT_METHOD(
+    showNotification : (NSString *)key options : (NSDictionary *)
+        options resolve : (RCTPromiseResolveBlock)resolve reject : (RCTPromiseRejectBlock)reject)
+{
+  dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+    BOOL success = [self.notificationRegistry showNotificationWithKey:key options:options];
+
+    if (success) {
+      resolve(@{@"success" : @true});
+    } else {
+      resolve(@{@"success" : @false, @"error" : @"Failed to show notification"});
+    }
+  });
+}
+
+RCT_EXPORT_METHOD(
+    updateNotification : (NSString *)key options : (NSDictionary *)
+        options resolve : (RCTPromiseResolveBlock)resolve reject : (RCTPromiseRejectBlock)reject)
+{
+  dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+    BOOL success = [self.notificationRegistry updateNotificationWithKey:key options:options];
+
+    if (success) {
+      resolve(@{@"success" : @true});
+    } else {
+      resolve(@{@"success" : @false, @"error" : @"Failed to update notification"});
+    }
+  });
+}
+
+RCT_EXPORT_METHOD(
+    hideNotification : (NSString *)key resolve : (RCTPromiseResolveBlock)
+        resolve reject : (RCTPromiseRejectBlock)reject)
+{
+  dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+    BOOL success = [self.notificationRegistry hideNotificationWithKey:key];
+
+    if (success) {
+      resolve(@{@"success" : @true});
+    } else {
+      resolve(@{@"success" : @false, @"error" : @"Failed to hide notification"});
+    }
+  });
+}
+
+RCT_EXPORT_METHOD(
+    unregisterNotification : (NSString *)key resolve : (RCTPromiseResolveBlock)
+        resolve reject : (RCTPromiseRejectBlock)reject)
+{
+  dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+    BOOL success = [self.notificationRegistry unregisterNotificationWithKey:key];
+
+    if (success) {
+      resolve(@{@"success" : @true});
+    } else {
+      resolve(@{@"success" : @false, @"error" : @"Failed to unregister notification"});
+    }
+  });
+}
+
+RCT_EXPORT_METHOD(
+    isNotificationActive : (NSString *)key resolve : (RCTPromiseResolveBlock)
+        resolve reject : (RCTPromiseRejectBlock)reject)
+{
+  dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+    BOOL isActive = [self.notificationRegistry isNotificationActiveWithKey:key];
+    resolve(@(isActive));
+  });
+}
+
 #ifdef RCT_NEW_ARCH_ENABLED
 - (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
     (const facebook::react::ObjCTurboModule::InitParams &)params

package/ios/audioapi/ios/system/AudioEngine.mm

@@ -255,10 +255,10 @@ static AudioEngine *_sharedInstance = nil;
   NSLog(@"================ 🎧 AVAudioEngine STATE ================");
 
   // AVAudioEngine state
-  NSLog(@"➡️ engine.isRunning: %@", self.audioEngine.isRunning ? @"YES" : @"NO");
+  NSLog(@"➡️ engine.isRunning: %@", self.audioEngine.isRunning ? @"true" : @"false");
   NSLog(
       @"➡️ engine.isInManualRenderingMode: %@",
-      self.audioEngine.isInManualRenderingMode ? @"YES" : @"NO");
+      self.audioEngine.isInManualRenderingMode ? @"true" : @"false");
 
   // Session state
   NSLog(@"🎚️ Session category: %@", session.category);

package/ios/audioapi/ios/system/AudioSessionManager.mm

@@ -182,7 +182,7 @@
       self.sessionCategory,
       self.sessionMode,
       (unsigned long)self.sessionOptions,
-      self.allowHapticsAndSystemSoundsDuringRecording ? @"YES" : @"NO");
+      self.allowHapticsAndSystemSoundsDuringRecording ? @"true" : @"false");
 
   NSError *error = nil;
 

package/ios/audioapi/ios/system/NotificationManager.mm

@@ -261,7 +261,7 @@ static NSString *NotificationManagerContext = @"NotificationManagerContext";
                                                            target:self
                                                          selector:@selector(checkSecondaryAudioHint)
                                                          userInfo:nil
-                                                          repeats:YES];
+                                                          repeats:true];
 
   [[NSRunLoop mainRunLoop] addTimer:self.hintPollingTimer forMode:NSRunLoopCommonModes];
 }