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

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,45 @@
+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/android/src/oldarch/NativeAudioAPIModuleSpec.java

@@ -10,79 +10,103 @@
  * @nolint
  */
 
- package com.swmansion.audioapi;
-
- import com.facebook.proguard.annotations.DoNotStrip;
- import com.facebook.react.bridge.Promise;
- import com.facebook.react.bridge.ReactApplicationContext;
- import com.facebook.react.bridge.ReactContextBaseJavaModule;
- import com.facebook.react.bridge.ReactMethod;
- import com.facebook.react.bridge.ReadableArray;
- import com.facebook.react.bridge.ReadableMap;
- import com.facebook.react.turbomodule.core.interfaces.TurboModule;
- import javax.annotation.Nonnull;
-
- public abstract class NativeAudioAPIModuleSpec extends ReactContextBaseJavaModule implements TurboModule {
-   public static final String NAME = "AudioAPIModule";
-
-   public NativeAudioAPIModuleSpec(ReactApplicationContext reactContext) {
-     super(reactContext);
-   }
-
-   @Override
-   public @Nonnull String getName() {
-     return NAME;
-   }
-
-   @ReactMethod(isBlockingSynchronousMethod = true)
-   @DoNotStrip
-   public abstract boolean install();
-
-   @ReactMethod(isBlockingSynchronousMethod = true)
-   @DoNotStrip
-   public abstract double getDevicePreferredSampleRate();
-
-   @ReactMethod
-   @DoNotStrip
-   public abstract void setAudioSessionActivity(boolean enabled, Promise promise);
-
-   @ReactMethod
-   @DoNotStrip
-   public abstract void setAudioSessionOptions(String category, String mode, ReadableArray options, boolean allowHaptics);
-
-   @ReactMethod
-   @DoNotStrip
-   public abstract void setLockScreenInfo(ReadableMap info);
-
-   @ReactMethod
-   @DoNotStrip
-   public abstract void resetLockScreenInfo();
-
-   @ReactMethod
-   @DoNotStrip
-   public abstract void enableRemoteCommand(String name, boolean enabled);
-
-   @ReactMethod
-   @DoNotStrip
-   public abstract void observeAudioInterruptions(boolean enabled);
-
-   @ReactMethod
-   @DoNotStrip
-   public abstract void activelyReclaimSession(boolean enabled);
-
-   @ReactMethod
-   @DoNotStrip
-   public abstract void observeVolumeChanges(boolean enabled);
-
-   @ReactMethod
-   @DoNotStrip
-   public abstract void requestRecordingPermissions(Promise promise);
-
-   @ReactMethod
-   @DoNotStrip
-   public abstract void checkRecordingPermissions(Promise promise);
-
-   @ReactMethod
-   @DoNotStrip
-   public abstract void getDevicesInfo(Promise promise);
- }
+package com.swmansion.audioapi;
+
+import com.facebook.proguard.annotations.DoNotStrip;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.turbomodule.core.interfaces.TurboModule;
+import javax.annotation.Nonnull;
+
+public abstract class NativeAudioAPIModuleSpec extends ReactContextBaseJavaModule implements TurboModule {
+  public static final String NAME = "AudioAPIModule";
+
+  public NativeAudioAPIModuleSpec(ReactApplicationContext reactContext) {
+    super(reactContext);
+  }
+
+  @Override
+  public @Nonnull String getName() {
+    return NAME;
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  @DoNotStrip
+  public abstract boolean install();
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  @DoNotStrip
+  public abstract double getDevicePreferredSampleRate();
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void setAudioSessionActivity(boolean enabled, Promise promise);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void setAudioSessionOptions(String category, String mode, ReadableArray options, boolean allowHaptics);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void disableSessionManagement();
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void observeAudioInterruptions(boolean enabled);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void activelyReclaimSession(boolean enabled);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void observeVolumeChanges(boolean enabled);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void requestRecordingPermissions(Promise promise);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void checkRecordingPermissions(Promise promise);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void requestNotificationPermissions(Promise promise);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void checkNotificationPermissions(Promise promise);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void getDevicesInfo(Promise promise);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void registerNotification(String type, String key, Promise promise);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void showNotification(String key, ReadableMap options, Promise promise);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void updateNotification(String key, ReadableMap options, Promise promise);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void hideNotification(String key, Promise promise);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void unregisterNotification(String key, Promise promise);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void isNotificationActive(String key, Promise promise);
+}