chore(notification): expand Android diagnostics and document iOS parity path

Author: ScottMorris

plugins/notification/android/src/main/java/NotificationPlugin.kt

@@ -12,6 +12,7 @@ import android.content.Context
 import android.content.Intent
 import android.os.Build
 import android.webkit.WebView
+import app.tauri.Logger
 import app.tauri.PermissionState
 import app.tauri.annotation.Command
 import app.tauri.annotation.InvokeArg
@@ -220,6 +221,7 @@ class NotificationPlugin(private val activity: Activity): Plugin(activity) {
 
     super.load(webView)
     this.webView = webView
+    Logger.debug(Logger.tags("Notification"), "Plugin load started")
     synchronized(this) {
       pendingActionEvents.clear()
       pendingActionEventKeys.clear()
@@ -239,6 +241,7 @@ class NotificationPlugin(private val activity: Activity): Plugin(activity) {
     this.manager = manager
 
     notificationManager = activity.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+    Logger.debug(Logger.tags("Notification"), "Plugin load complete; awaiting notification intents")
 
     val intent = activity.intent
     intent?.let {
@@ -248,16 +251,21 @@ class NotificationPlugin(private val activity: Activity): Plugin(activity) {
 
   override fun onNewIntent(intent: Intent) {
     super.onNewIntent(intent)
+    Logger.debug(Logger.tags("Notification"), "onNewIntent received action=${intent.action}")
     onIntent(intent)
   }
 
   fun onIntent(intent: Intent) {
     if (Intent.ACTION_MAIN != intent.action) {
+      Logger.debug(Logger.tags("Notification"), "Ignoring intent action=${intent.action}")
       return
     }
+    Logger.debug(Logger.tags("Notification"), "Processing ACTION_MAIN intent for notification action")
     val dataJson = manager.handleNotificationActionPerformed(intent, notificationStorage)
     if (dataJson != null) {
       dispatchActionPerformed(dataJson)
+    } else {
+      Logger.debug(Logger.tags("Notification"), "No action payload extracted from intent")
     }
   }
 
@@ -284,12 +292,17 @@ class NotificationPlugin(private val activity: Activity): Plugin(activity) {
         return
       }
     }
+    Logger.debug(Logger.tags("Notification"), "Dispatching actionPerformed event immediately")
     trigger("actionPerformed", payload)
   }
 
   @Command
   fun show(invoke: Invoke) {
     val notification = invoke.parseArgs(Notification::class.java)
+    Logger.debug(
+      Logger.tags("Notification"),
+      "show called id=${notification.id} title=${notification.title} actionTypeId=${notification.actionTypeId} hasSchedule=${notification.schedule != null}"
+    )
     val id = manager.schedule(notification)
 
     invoke.resolveObject(id)
@@ -298,23 +311,30 @@ class NotificationPlugin(private val activity: Activity): Plugin(activity) {
   @Command
   fun batch(invoke: Invoke) {
     val args = invoke.parseArgs(BatchArgs::class.java)
+    Logger.debug(
+      Logger.tags("Notification"),
+      "batch called notifications=${args.notifications.size}"
+    )
 
     val ids = manager.schedule(args.notifications)
     notificationStorage.appendNotifications(args.notifications)
+    Logger.debug(Logger.tags("Notification"), "batch scheduled ids=$ids")
 
     invoke.resolveObject(ids)
   }
 
   @Command
   fun cancel(invoke: Invoke) {
     val args = invoke.parseArgs(CancelArgs::class.java)
+    Logger.debug(Logger.tags("Notification"), "cancel called notifications=${args.notifications}")
     manager.cancel(args.notifications)
     invoke.resolve()
   }
 
   @Command
   fun removeActive(invoke: Invoke) {
     val args = invoke.parseArgs(RemoveActiveArgs::class.java)
+    Logger.debug(Logger.tags("Notification"), "removeActive called notifications=${args.notifications.size}")
 
     if (args.notifications.isEmpty()) {
       notificationManager.cancelAll()
@@ -334,29 +354,40 @@ class NotificationPlugin(private val activity: Activity): Plugin(activity) {
   @Command
   fun getPending(invoke: Invoke) {
     val notifications= notificationStorage.getSavedNotifications()
+    Logger.debug(Logger.tags("Notification"), "getPending returning count=${notifications.size}")
     val result = Notification.buildNotificationPendingList(notifications)
     invoke.resolveObject(result)
   }
 
   @Command
   fun registerActionTypes(invoke: Invoke) {
     val args = invoke.parseArgs(RegisterActionTypesArgs::class.java)
+    Logger.debug(
+      Logger.tags("Notification"),
+      "registerActionTypes called types=${args.types.size}"
+    )
     notificationStorage.writeActionGroup(args.types)
     invoke.resolve()
   }
 
   @Command
   fun registerActionListenerReady(invoke: Invoke) {
     val pending = JSArray()
+    var drainedCount = 0
     synchronized(this) {
       isActionListenerReady = true
       for (event in pendingActionEvents) {
         pending.put(event.payload)
       }
+      drainedCount = pendingActionEvents.size
       pendingActionEvents.clear()
       pendingActionEventKeys.clear()
       persistPendingActionEventsLocked()
     }
+    Logger.debug(
+      Logger.tags("Notification"),
+      "Action listener marked ready; drained pending actionPerformed events=$drainedCount"
+    )
     invoke.resolveObject(pending)
   }
 

plugins/notification/android/src/main/java/TauriNotificationManager.kt

@@ -70,6 +70,10 @@ class TauriNotificationManager(
     val input = results?.getCharSequence(REMOTE_INPUT_KEY)
     dataJson.put("inputValue", input?.toString())
     val menuAction = data.getStringExtra(ACTION_INTENT_KEY)
+    Logger.debug(
+      Logger.tags("Notification"),
+      "Action performed id=$notificationId actionId=$menuAction removable=$isRemovable"
+    )
     dismissVisibleNotification(notificationId)
     dataJson.put("actionId", menuAction)
     var request: JSONObject? = null
@@ -87,6 +91,10 @@ class TauriNotificationManager(
       if (savedNotification?.actionTypeId != null) {
         request.put("actionTypeId", savedNotification.actionTypeId)
       }
+      Logger.debug(
+        Logger.tags("Notification"),
+        "Recovered missing notification metadata from storage id=$notificationId actionTypeId=${savedNotification?.actionTypeId}"
+      )
     } else if (!request.has("id")) {
       request.put("id", notificationId)
     }
@@ -136,17 +144,23 @@ class TauriNotificationManager(
 
   fun schedule(notification: Notification): Int {
     val notificationManager = NotificationManagerCompat.from(context)
+    Logger.debug(
+      Logger.tags("Notification"),
+      "Scheduling notification id=${notification.id} actionTypeId=${notification.actionTypeId} hasSchedule=${notification.schedule != null}"
+    )
     return trigger(notificationManager, notification)
   }
 
   fun schedule(notifications: List<Notification>): List<Int> {
     val ids = mutableListOf<Int>()
     val notificationManager = NotificationManagerCompat.from(context)
+    Logger.debug(Logger.tags("Notification"), "Scheduling batch notifications count=${notifications.size}")
 
     for (notification in notifications) {
       val id = trigger(notificationManager, notification)
       ids.add(id)
     }
+    Logger.debug(Logger.tags("Notification"), "Scheduled batch notification ids=$ids")
 
     return ids
   }
@@ -324,6 +338,10 @@ class TauriNotificationManager(
     intent.putExtra(NOTIFICATION_OBJ_INTENT_KEY, notificationJson.toString())
     val schedule = notification.schedule
     intent.putExtra(NOTIFICATION_IS_REMOVABLE_KEY, schedule == null || schedule.isRemovable())
+    Logger.debug(
+      Logger.tags("Notification"),
+      "Built action intent notificationId=${notification.id} action=$action removable=${schedule == null || schedule.isRemovable()}"
+    )
     return intent
   }
 

plugins/notification/ios/Sources/NotificationHandler.swift

@@ -75,10 +75,17 @@ public class NotificationHandler: NSObject, NotificationHandlerProtocol {
     // Delivery note:
     // This event is emitted as soon as the OS callback arrives. If the JS side has
     // not attached `onAction` yet (for example during cold start), the event may be
-    // missed. Android currently mitigates this with a pending-action queue drained
-    // by JS after listener registration.
+    // missed. Android mitigates this with a pending-action queue and an explicit
+    // "listener ready" handshake from JS.
     //
-    // TODO: Consider applying the same queue/drain handshake on iOS for parity.
+    // iOS parity guidance:
+    // 1. Queue `ReceivedNotification` payloads at this boundary when listeners are not ready.
+    // 2. Expose a small command that JS calls after `onAction` registration to drain the queue.
+    // 3. Consider persistence (for example `UserDefaults`) so queued actions survive process restarts.
+    // 4. Keep the payload contract aligned with Android (`actionId`, `inputValue`, `notification`).
+    //
+    // Important: queue payloads should be built from `UNNotificationResponse` fields directly
+    // where possible, since `notificationsMap` is in-memory and may be unavailable after restart.
     try? self.plugin?.trigger(
       "actionPerformed",
       data: ReceivedNotification(