react-native-audio-api 0.11.0-nightly-b30bac9-20260114 → 0.11.0

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

@@ -3,7 +3,6 @@ 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
 
 /**
@@ -12,7 +11,8 @@ import com.swmansion.audioapi.AudioAPIModule
 class PlaybackNotificationReceiver : BroadcastReceiver() {
   companion object {
     const val ACTION_NOTIFICATION_DISMISSED = "com.swmansion.audioapi.PLAYBACK_NOTIFICATION_DISMISSED"
-    private const val TAG = "PlaybackNotificationReceiver"
+    const val ACTION_SKIP_FORWARD = "com.swmansion.audioapi.ACTION_SKIP_FORWARD"
+    const val ACTION_SKIP_BACKWARD = "com.swmansion.audioapi.ACTION_SKIP_BACKWARD"
 
     private var audioAPIModule: AudioAPIModule? = null
 
@@ -26,8 +26,13 @@ class PlaybackNotificationReceiver : BroadcastReceiver() {
     intent: Intent?,
   ) {
     if (intent?.action == ACTION_NOTIFICATION_DISMISSED) {
-      Log.d(TAG, "Notification dismissed by user")
       audioAPIModule?.invokeHandlerWithEventNameAndEventBody("playbackNotificationDismissed", mapOf())
+    } else if (intent?.action == ACTION_SKIP_FORWARD) {
+      val body = HashMap<String, Any>().apply { put("value", 15) }
+      audioAPIModule?.invokeHandlerWithEventNameAndEventBody("playbackNotificationSkipForward", body)
+    } else if (intent?.action == ACTION_SKIP_BACKWARD) {
+      val body = HashMap<String, Any>().apply { put("value", 15) }
+      audioAPIModule?.invokeHandlerWithEventNameAndEventBody("playbackNotificationSkipBackward", body)
     }
   }
 }

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

@@ -4,300 +4,318 @@ import android.app.Notification
 import android.app.NotificationChannel
 import android.app.NotificationManager
 import android.app.PendingIntent
+import android.content.ComponentCallbacks
 import android.content.Context
 import android.content.Intent
 import android.content.IntentFilter
+import android.content.res.Configuration
 import android.graphics.Color
+import android.graphics.drawable.Icon
 import android.os.Build
 import android.util.Log
+import android.widget.RemoteViews
+import androidx.annotation.RequiresApi
 import androidx.core.app.NotificationCompat
+import androidx.core.content.ContextCompat
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReadableMap
 import com.swmansion.audioapi.AudioAPIModule
+import com.swmansion.audioapi.R
+import com.swmansion.audioapi.system.notification.state.RecordingNotificationState
 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 {
+) : BaseNotification,
+  ComponentCallbacks {
   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"
+    const val ID = 200
   }
 
-  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
+  private var state: RecordingNotificationState =
+    RecordingNotificationState(
+      darkTheme =
+        reactContext
+          .get()!!
+          .resources.configuration.uiMode and Configuration.UI_MODE_NIGHT_MASK == Configuration.UI_MODE_NIGHT_YES,
+      initialized = false,
+    )
 
-  override fun init(params: ReadableMap?): Notification {
+  private fun initializeNotification() {
     val context = reactContext.get() ?: throw IllegalStateException("React context is null")
+    if (!state.initialized) {
+      context.registerComponentCallbacks(this)
+      createNotificationChannel(context)
+      state.receiver =
+        RecordingNotificationReceiver(audioAPIModule.get()!!)
+      val filter =
+        IntentFilter().apply {
+          addAction(RecordingNotificationReceiver.NOTIFICATION_RECORDING_STOPPED)
+          addAction(RecordingNotificationReceiver.NOTIFICATION_RECORDING_RESUMED)
+        }
+      ContextCompat.registerReceiver(
+        context,
+        state.receiver,
+        filter,
+        ContextCompat.RECEIVER_NOT_EXPORTED,
+      )
 
-    // Register broadcast receiver
-    registerReceiver()
+      state.pauseIntent =
+        Intent(RecordingNotificationReceiver.NOTIFICATION_RECORDING_STOPPED).apply {
+          `package` = context.packageName
+        }
 
-    // Create notification channel first
-    createNotificationChannel()
+      state.resumeIntent =
+        Intent(RecordingNotificationReceiver.NOTIFICATION_RECORDING_RESUMED).apply {
+          `package` = context.packageName
+        }
+      state.darkTheme = context.resources.configuration.uiMode and Configuration.UI_MODE_NIGHT_MASK == Configuration.UI_MODE_NIGHT_YES
+      state.initialized = true
+    }
+  }
 
-    // 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)
+  override fun show(options: ReadableMap?): Notification {
+    initializeNotification()
+    val context = reactContext.get() ?: throw IllegalStateException("React context is null")
+    if (options != state.cachedRNOptions) {
+      state.cachedRNOptions = options
+      parseMapFromRN(options)
+    }
+    val builder = getBuilder()
 
-    // Set content intent to open app
-    val packageName = context.packageName
-    val openAppIntent = context.packageManager.getLaunchIntentForPackage(packageName)
-    if (openAppIntent != null) {
-      val pendingIntent =
-        PendingIntent.getActivity(
+    if (state.smallIconResourceName != null) {
+      builder.setSmallIcon(context.resources.getIdentifier(state.smallIconResourceName, "drawable", context.packageName))
+    }
+
+    if (state.largeIconResourceName != null) {
+      val icon =
+        Icon.createWithResource(
           context,
-          0,
-          openAppIntent,
-          PendingIntent.FLAG_IMMUTABLE,
+          context.resources.getIdentifier(state.largeIconResourceName, "drawable", context.packageName),
         )
-      notificationBuilder?.setContentIntent(pendingIntent)
+      builder.setLargeIcon(icon)
     }
 
-    // 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)
+    if (state.backgroundColor != null) {
+      builder.setColor(state.backgroundColor!!)
     }
 
-    return buildNotification()
-  }
+    val collapsedView = RemoteViews(context.packageName, R.layout.notification_collapsed)
+    val expandedView = RemoteViews(context.packageName, R.layout.notification_expanded)
 
-  override fun reset() {
-    // Unregister receiver
-    unregisterReceiver()
+    val (pauseResumePendingIntent, iconId) = setupPauseResumeIntent(context)
 
-    // Reset state
-    title = "Audio Recording"
-    description = "Ready to record"
-    isRecording = false
-    notificationBuilder = null
-  }
+    setupRemoteView(listOf(collapsedView, expandedView), pauseResumePendingIntent, iconId)
 
-  override fun getNotificationId(): Int = notificationId
+    builder
+      .setStyle(NotificationCompat.DecoratedCustomViewStyle())
+      .setCustomContentView(collapsedView)
+      .setCustomBigContentView(expandedView)
+      .setContentTitle(state.title)
+      .setContentText(state.contentText)
 
-  override fun getChannelId(): String = channelId
-
-  override fun update(options: ReadableMap?): Notification {
-    if (options == null) {
-      return buildNotification()
+    if (state.backgroundColor != null) {
+      builder.setColor(state.backgroundColor!!)
     }
 
-    // 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()
-    }
+    return builder.build()
+  }
 
-    // Update metadata
-    if (options.hasKey("title")) {
-      title = options.getString("title") ?: "Audio Recording"
-    }
+  private fun setupPauseResumeIntent(context: Context): Pair<PendingIntent, Int> {
+    val pauseResumeIntent =
+      if (state.paused) {
+        state.resumeIntent
+      } else {
+        state.pauseIntent
+      }
 
-    if (options.hasKey("description")) {
-      description = options.getString("description") ?: "Ready to record"
-    }
+    val pauseResumePendingIntent =
+      PendingIntent.getBroadcast(
+        context,
+        0,
+        pauseResumeIntent!!,
+        PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE,
+      )
 
-    // Update recording state
-    if (options.hasKey("state")) {
-      when (options.getString("state")) {
-        "recording" -> isRecording = true
-        "stopped" -> isRecording = false
+    val pauseId =
+      if (state.pauseIconResourceName != null) {
+        context.resources.getIdentifier(state.pauseIconResourceName, "drawable", context.packageName)
+      } else {
+        android.R.drawable.ic_media_pause
       }
-    }
-
-    // Update notification content
-    val statusText =
-      description.ifEmpty {
-        if (isRecording) "Recording..." else "Ready to record"
+    val resumeId =
+      if (state.resumeIconResourceName != null) {
+        context.resources.getIdentifier(state.resumeIconResourceName, "drawable", context.packageName)
+      } else {
+        android.R.drawable.ic_media_play
       }
-    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()
+    val iconId = if (state.paused) resumeId else pauseId
+    return pauseResumePendingIntent to iconId
   }
 
-  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)
+  private fun setupRemoteView(
+    views: List<RemoteViews>,
+    pauseResumePendingIntent: PendingIntent,
+    iconId: Int,
+  ) {
+    val iconColor =
+      if (state.darkTheme) {
+        Color.WHITE // Dark Mode -> White Icon
+      } else {
+        Color.BLACK // Light Mode -> Black Icon
+      }
+    for (view in views) {
+      view.setTextViewText(R.id.notification_title, state.title)
+      view.setTextViewText(R.id.notification_content, state.contentText)
+      view.setImageViewResource(R.id.notification_action_btn, iconId)
+      view.setInt(R.id.notification_action_btn, "setColorFilter", iconColor)
+      view.setOnClickPendingIntent(R.id.notification_action_btn, pauseResumePendingIntent)
     }
+  }
 
-    // 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),
-    )
+// not used currently, left for future reference
+//  private fun loadBitmapFromUri(
+//    context: Context,
+//    uriString: String?,
+//  ): Bitmap? =
+//    try {
+//      val uri = android.net.Uri.parse(uriString)
+//      val inputStream: InputStream
+//      if (uri.scheme == "http" || uri.scheme == "https") {
+//        // web URL
+//        val connection = java.net.URL(uriString).openConnection()
+//        connection.doInput = true
+//        connection.connect()
+//        inputStream = connection.inputStream
+//      } else {
+//        // local files
+//        inputStream = context.contentResolver.openInputStream(uri)!!
+//      }
+//      android.graphics.BitmapFactory.decodeStream(inputStream)
+//    } catch (e: Exception) {
+//      Log.e(TAG, "Failed to load bitmap from URI: $uriString", e)
+//      null
+//    }
+
+  private fun getBuilder(): NotificationCompat.Builder {
+    val context = reactContext.get() ?: throw IllegalStateException("React context is null")
+    if (state.builder == null) {
+      val openAppIntent = context.packageManager.getLaunchIntentForPackage(context.packageName)
+      val pendingIntent = PendingIntent.getActivity(context, 0, openAppIntent, PendingIntent.FLAG_IMMUTABLE)
+
+      state.builder =
+        NotificationCompat
+          .Builder(context, channelId)
+          .setOngoing(true)
+          .setContentIntent(pendingIntent)
+    }
+    if (state.smallIconResourceName == null) {
+      state.builder!!.setSmallIcon(android.R.drawable.ic_btn_speak_now)
+    }
+    return state.builder!!
   }
 
-  private fun createNotificationChannel() {
+  private fun createNotificationChannel(context: ReactApplicationContext) {
     if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-      val context = reactContext.get() ?: return
-
       val channel =
         NotificationChannel(
           channelId,
-          "Audio Recording",
-          NotificationManager.IMPORTANCE_HIGH,
+          "Recording Audio",
+          NotificationManager.IMPORTANCE_LOW,
         ).apply {
-          description = "Recording controls and status"
-          setShowBadge(true)
+          description = "Notifications for ongoing audio recordings"
           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")
     }
+    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)
+  private fun parseMapFromRN(options: ReadableMap?) {
+    state.title = if (options?.hasKey("title") == true) options.getString("title") else state.title ?: "Recording Audio"
+    state.contentText =
+      if (options?.hasKey("contentText") == true) {
+        options.getString("contentText")
+      } else {
+        state.contentText ?: "Audio recording is in progress/paused"
+      }
+    state.smallIconResourceName =
+      if (options?.hasKey("smallIconResourceName") ==
+        true
+      ) {
+        options.getString("smallIconResourceName")
+      } else {
+        state.smallIconResourceName ?: null
+      }
+    state.largeIconResourceName =
+      if (options?.hasKey("largeIconResourceName") ==
+        true
+      ) {
+        options.getString("largeIconResourceName")
+      } else {
+        state.largeIconResourceName ?: null
+      }
+    state.pauseIconResourceName =
+      if (options?.hasKey("pauseIconResourceName") ==
+        true
+      ) {
+        options.getString("pauseIconResourceName")
       } else {
-        context.registerReceiver(receiver, filter)
+        state.pauseIconResourceName ?: null
       }
+    state.resumeIconResourceName =
+      if (options?.hasKey("resumeIconResourceName") ==
+        true
+      ) {
+        options.getString("resumeIconResourceName")
+      } else {
+        state.resumeIconResourceName ?: null
+      }
+    state.backgroundColor = if (options?.hasKey("color") == true) options.getInt("color") else state.backgroundColor ?: null
+    state.paused = if (options?.hasKey("paused") == true) options.getBoolean("paused") else false
+  }
 
-      Log.d(TAG, "RecordingNotificationReceiver registered")
+  override fun hide() {
+    val context = reactContext.get() ?: throw IllegalStateException("React context is null")
+    if (state.receiver != null) {
+      context.unregisterReceiver(state.receiver)
+      context.unregisterComponentCallbacks(this)
+      state.receiver = null
     }
+    val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+    notificationManager.cancel(notificationId)
+    state.initialized = false
+    state.builder = null
   }
 
-  private fun unregisterReceiver() {
-    val context = reactContext.get() ?: return
+  override fun getNotificationId(): Int = notificationId
 
-    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)
+  override fun getChannelId(): String = channelId
+
+  @RequiresApi(Build.VERSION_CODES.O)
+  override fun onConfigurationChanged(newConfig: Configuration) {
+    val currentNightMode = newConfig.uiMode and Configuration.UI_MODE_NIGHT_MASK == Configuration.UI_MODE_NIGHT_YES
+    if (currentNightMode != state.darkTheme) {
+      // Theme changed, rebuild notification
+      state.darkTheme = currentNightMode
+      val notification = show(state.cachedRNOptions)
+      val context = reactContext.get()
+      if (context != null) {
+        val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+        notificationManager.notify(notificationId, notification)
       }
     }
   }
+
+  @Deprecated("Deprecated in Java")
+  override fun onLowMemory() {
+    // left to listen for ui mode changes
+  }
 }

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

@@ -6,19 +6,13 @@ 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() {
+class RecordingNotificationReceiver(
+  private val module: AudioAPIModule,
+) : BroadcastReceiver() {
   companion object {
-    const val ACTION_NOTIFICATION_DISMISSED = "com.swmansion.audioapi.RECORDING_NOTIFICATION_DISMISSED"
+    const val NOTIFICATION_RECORDING_STOPPED = "com.swmansion.audioapi.NOTIFICATION_RECORDING_STOPPED"
+    const val NOTIFICATION_RECORDING_RESUMED = "com.swmansion.audioapi.NOTIFICATION_RECORDING_RESUMED"
     private const val TAG = "RecordingNotificationReceiver"
-
-    private var audioAPIModule: AudioAPIModule? = null
-
-    fun setAudioAPIModule(module: AudioAPIModule?) {
-      audioAPIModule = module
-    }
   }
 
   override fun onReceive(
@@ -26,19 +20,14 @@ class RecordingNotificationReceiver : BroadcastReceiver() {
     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())
+      NOTIFICATION_RECORDING_STOPPED -> {
+        Log.d(TAG, "Recording stopped via notification")
+        module.invokeHandlerWithEventNameAndEventBody("recordingNotificationPause", mapOf())
       }
 
-      RecordingNotification.ACTION_STOP -> {
-        Log.d(TAG, "Stop recording action received")
-        audioAPIModule?.invokeHandlerWithEventNameAndEventBody("recordingNotificationStop", mapOf())
+      NOTIFICATION_RECORDING_RESUMED -> {
+        Log.d(TAG, "Recording resumed via notification")
+        module.invokeHandlerWithEventNameAndEventBody("recordingNotificationResume", mapOf())
       }
     }
   }

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

@@ -0,0 +1,24 @@
+package com.swmansion.audioapi.system.notification.state
+
+import android.content.Intent
+import androidx.core.app.NotificationCompat
+import com.facebook.react.bridge.ReadableMap
+import com.swmansion.audioapi.system.notification.RecordingNotificationReceiver
+
+data class RecordingNotificationState(
+  var builder: NotificationCompat.Builder? = null,
+  var receiver: RecordingNotificationReceiver? = null,
+  var initialized: Boolean,
+  var pauseIntent: Intent? = null,
+  var resumeIntent: Intent? = null,
+  var title: String? = null,
+  var contentText: String? = null,
+  var paused: Boolean = false,
+  var smallIconResourceName: String? = null,
+  var largeIconResourceName: String? = null,
+  var pauseIconResourceName: String? = null,
+  var resumeIconResourceName: String? = null,
+  var backgroundColor: Int? = null,
+  var cachedRNOptions: ReadableMap? = null,
+  var darkTheme: Boolean,
+)

package/android/src/main/res/layout/btn_round_ripple.xml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8"?>
+<ripple xmlns:android="http://schemas.android.com/apk/res/android"
+    android:color="?android:attr/colorControlHighlight">
+  <item android:id="@android:id/mask">
+    <shape android:shape="oval">
+      <solid android:color="#FFFFFF" />
+    </shape>
+  </item>
+</ripple>