@onesignal/capacitor-plugin 1.0.1 → 1.0.3

package/OneSignalCapacitorPlugin.podspec

@@ -10,7 +10,11 @@ Pod::Spec.new do |s|
   s.homepage = package['homepage']
   s.author = 'OneSignal'
   s.source = { :git => package['repository']['url'], :tag => s.version.to_s }
-  s.source_files = 'ios/Sources/OneSignalCapacitorPlugin/**/*.swift'
+  s.source_files = [
+    'ios/Sources/OneSignalCapacitorPlugin/**/*.swift',
+    'ios/Sources/OSCapacitorLaunchOptions/**/*.{h,m}'
+  ]
+  s.public_header_files = 'ios/Sources/OSCapacitorLaunchOptions/include/*.h'
 
   s.ios.deployment_target = '14.0'
   s.swift_version = '5.9'

package/Package.swift

@@ -16,6 +16,16 @@ let package = Package(
         .package(url: "https://github.com/OneSignal/OneSignal-XCFramework", from: "5.0.0")
     ],
     targets: [
+        // Obj-C helper that captures the iOS launchOptions dictionary at
+        // process start (via +load + UIApplicationDidFinishLaunchingNotification)
+        // so cold-start notification taps are still available when the JS
+        // layer initializes the plugin later. SPM cannot mix Swift and Obj-C
+        // in the same target, so this lives as its own target.
+        .target(
+            name: "OSCapacitorLaunchOptions",
+            path: "ios/Sources/OSCapacitorLaunchOptions",
+            publicHeadersPath: "include"
+        ),
         .target(
             name: "OnesignalCapacitorPlugin",
             dependencies: [
@@ -28,7 +38,8 @@ let package = Package(
                 .product(name: "OneSignalFramework", package: "OneSignal-XCFramework"),
                 .product(name: "OneSignalInAppMessages", package: "OneSignal-XCFramework"),
                 .product(name: "OneSignalLocation", package: "OneSignal-XCFramework"),
-                .product(name: "OneSignalExtension", package: "OneSignal-XCFramework")
+                .product(name: "OneSignalExtension", package: "OneSignal-XCFramework"),
+                "OSCapacitorLaunchOptions"
             ],
             path: "ios/Sources/OneSignalCapacitorPlugin"
         )

package/android/gradle/libs.versions.toml

@@ -14,7 +14,7 @@ compileSdk = "35"
 junit = "4.13.2"
 kotlin = "1.9.25"
 minSdk = "23"
-onesignal = "5.8.1"
+onesignal = "5.9.1"
 targetSdk = "35"
 
 [libraries]

package/android/src/main/kotlin/com/onesignal/capacitor/OneSignalCapacitorPlugin.kt

@@ -1,5 +1,6 @@
 package com.onesignal.capacitor
 
+import android.app.Application
 import com.getcapacitor.JSObject
 import com.getcapacitor.Plugin
 import com.getcapacitor.PluginCall
@@ -7,6 +8,7 @@ import com.getcapacitor.PluginMethod
 import com.getcapacitor.annotation.CapacitorPlugin
 import com.onesignal.OneSignal
 import com.onesignal.common.OneSignalWrapper
+import com.onesignal.core.internal.application.IApplicationService
 import com.onesignal.inAppMessages.IInAppMessageClickEvent
 import com.onesignal.inAppMessages.IInAppMessageClickListener
 import com.onesignal.inAppMessages.IInAppMessageDidDismissEvent
@@ -24,8 +26,8 @@ import com.onesignal.user.state.IUserStateObserver
 import com.onesignal.user.state.UserChangedState
 import com.onesignal.user.subscriptions.IPushSubscriptionObserver
 import com.onesignal.user.subscriptions.PushSubscriptionChangedState
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.MainScope
+import kotlinx.coroutines.cancel
 import kotlinx.coroutines.launch
 import org.json.JSONArray
 import org.json.JSONObject
@@ -37,11 +39,82 @@ class OneSignalCapacitorPlugin : Plugin(),
     IInAppMessageLifecycleListener,
     IInAppMessageClickListener {
 
+    companion object {
+        // Mirror of iOS UNAuthorizationStatus values so the JS layer can use a
+        // single permissionNative() return shape across platforms. Android only
+        // distinguishes denied/authorized; the iOS-specific notDetermined (0),
+        // provisional (3), and ephemeral (4) states do not apply here.
+        private const val PERMISSION_DENIED = 1
+        private const val PERMISSION_AUTHORIZED = 2
+    }
+
     private val notificationWillDisplayCache = mutableMapOf<String, INotificationWillDisplayEvent>()
     private val preventDefaultCache = mutableSetOf<String>()
-    private var pendingClickEvent: INotificationClickEvent? = null
+    private var initialized = false
+
+    // Class-scoped scope so launched permission/location coroutines are tied
+    // to the plugin instance lifetime. Cancelled in handleOnDestroy so a
+    // pending permission dialog that resolves after the activity dies cannot
+    // call into the dead Capacitor bridge.
+    private val pluginScope = MainScope()
+
+    private val permissionObserver = object : IPermissionObserver {
+        override fun onNotificationPermissionChange(permission: Boolean) {
+            val ret = JSObject()
+            ret.put("permission", permission)
+            notifyListeners("permissionChange", ret)
+        }
+    }
+
+    private val pushSubscriptionObserver = object : IPushSubscriptionObserver {
+        override fun onPushSubscriptionChange(state: PushSubscriptionChangedState) {
+            val ret = JSObject()
+            val prev = JSObject()
+            prev.put("id", state.previous.id.ifEmpty { JSONObject.NULL })
+            prev.put("token", state.previous.token.ifEmpty { JSONObject.NULL })
+            prev.put("optedIn", state.previous.optedIn)
+            ret.put("previous", prev)
+
+            val curr = JSObject()
+            curr.put("id", state.current.id.ifEmpty { JSONObject.NULL })
+            curr.put("token", state.current.token.ifEmpty { JSONObject.NULL })
+            curr.put("optedIn", state.current.optedIn)
+            ret.put("current", curr)
+
+            notifyListeners("pushSubscriptionChange", ret)
+        }
+    }
+
+    private val userStateObserver = object : IUserStateObserver {
+        override fun onUserStateChange(state: UserChangedState) {
+            val ret = JSObject()
+            val curr = JSObject()
+            curr.put("onesignalId", state.current.onesignalId.ifEmpty { JSONObject.NULL })
+            curr.put("externalId", state.current.externalId.ifEmpty { JSONObject.NULL })
+            ret.put("current", curr)
+            notifyListeners("userStateChange", ret)
+        }
+    }
 
-    // region Core
+    override fun handleOnDestroy() {
+        // Detach this dead plugin instance so the next plugin instance can
+        // receive events; otherwise the SDK keeps firing on this stale
+        // instance and skips its unprocessed-click replay queue.
+        runCatching {
+            OneSignal.Notifications.removePermissionObserver(permissionObserver)
+            OneSignal.Notifications.removeForegroundLifecycleListener(this)
+            OneSignal.Notifications.removeClickListener(this)
+            OneSignal.User.pushSubscription.removeObserver(pushSubscriptionObserver)
+            OneSignal.User.removeObserver(userStateObserver)
+            OneSignal.InAppMessages.removeLifecycleListener(this)
+            OneSignal.InAppMessages.removeClickListener(this)
+        }
+        pluginScope.cancel()
+        // Caches aren't explicitly cleared: GC reclaims them with this
+        // instance once the listener removals above run, and runtime size is
+        // bounded by consume-on-read in proceedWithWillDisplay/displayNotification.
+        super.handleOnDestroy()
+    }
 
     @PluginMethod
     fun initialize(call: PluginCall) {
@@ -51,68 +124,56 @@ class OneSignalCapacitorPlugin : Plugin(),
             return
         }
 
+        // initialize() is idempotent: JS may call it multiple times per
+        // activity (effect re-runs, hot reload). Listeners are detached in
+        // handleOnDestroy and the next plugin instance starts fresh.
+        if (initialized) {
+            call.resolve()
+            return
+        }
+        initialized = true
+
         OneSignalWrapper.sdkType = "capacitor"
-        OneSignalWrapper.sdkVersion = "010000"
+        OneSignalWrapper.sdkVersion = "010003"
         OneSignal.initWithContext(context, appId)
 
-        OneSignal.Notifications.addPermissionObserver(object : IPermissionObserver {
-            override fun onNotificationPermissionChange(permission: Boolean) {
-                val ret = JSObject()
-                ret.put("permission", permission)
-                notifyListeners("permissionChange", ret)
-            }
-        })
+        // If the SDK was initialized from a non-Activity context (FCM/work
+        // managers) before this call, its ALC missed MainActivity.onResume
+        // and isInForeground stays false. Forward the missed events now.
+        nudgeApplicationServiceForeground()
 
+        OneSignal.Notifications.addPermissionObserver(permissionObserver)
         OneSignal.Notifications.addForegroundLifecycleListener(this)
         OneSignal.Notifications.addClickListener(this)
-
-        OneSignal.User.pushSubscription.addObserver(object : IPushSubscriptionObserver {
-            override fun onPushSubscriptionChange(state: PushSubscriptionChangedState) {
-                val ret = JSObject()
-                val prev = JSObject()
-                prev.put("id", state.previous.id.ifEmpty { JSONObject.NULL })
-                prev.put("token", state.previous.token.ifEmpty { JSONObject.NULL })
-                prev.put("optedIn", state.previous.optedIn)
-                ret.put("previous", prev)
-
-                val curr = JSObject()
-                curr.put("id", state.current.id.ifEmpty { JSONObject.NULL })
-                curr.put("token", state.current.token.ifEmpty { JSONObject.NULL })
-                curr.put("optedIn", state.current.optedIn)
-                ret.put("current", curr)
-
-                notifyListeners("pushSubscriptionChange", ret)
-            }
-        })
-
-        OneSignal.User.addObserver(object : IUserStateObserver {
-            override fun onUserStateChange(state: UserChangedState) {
-                val ret = JSObject()
-                val curr = JSObject()
-                curr.put("onesignalId", state.current.onesignalId.ifEmpty { JSONObject.NULL })
-                curr.put("externalId", state.current.externalId.ifEmpty { JSONObject.NULL })
-                ret.put("current", curr)
-                notifyListeners("userStateChange", ret)
-            }
-        })
-
+        OneSignal.User.pushSubscription.addObserver(pushSubscriptionObserver)
+        OneSignal.User.addObserver(userStateObserver)
         OneSignal.InAppMessages.addLifecycleListener(this)
         OneSignal.InAppMessages.addClickListener(this)
 
-        pendingClickEvent?.let { event ->
-            val ret = JSObject()
-            val clickResult = JSObject()
-            clickResult.put("actionId", event.result.actionId)
-            clickResult.put("url", event.result.url)
-            ret.put("result", clickResult)
-            ret.put("notification", JSObject(event.notification.rawPayload))
-            notifyListeners("notificationClick", ret)
-            pendingClickEvent = null
-        }
-
         call.resolve()
     }
 
+    /** Forward the missed activity-resume to the SDK so isInForeground is
+     *  correct on cold start. No-op if the SDK already saw the resume. */
+    private fun nudgeApplicationServiceForeground() {
+        val activity = activity ?: return
+        val appSvc = runCatching { OneSignal.getServiceOrNull<IApplicationService>() }.getOrNull() ?: return
+        if (appSvc.isInForeground && appSvc.current === activity) return
+        val callbacks = appSvc as? Application.ActivityLifecycleCallbacks ?: return
+        callbacks.onActivityStarted(activity)
+        callbacks.onActivityResumed(activity)
+    }
+
+    private fun buildClickEventJson(event: INotificationClickEvent): JSObject {
+        val ret = JSObject()
+        val clickResult = JSObject()
+        clickResult.put("actionId", event.result.actionId)
+        clickResult.put("url", event.result.url)
+        ret.put("result", clickResult)
+        ret.put("notification", serializeNotification(event.notification))
+        return ret
+    }
+
     @PluginMethod
     fun login(call: PluginCall) {
         val externalId = call.getString("externalId")
@@ -144,8 +205,6 @@ class OneSignalCapacitorPlugin : Plugin(),
         call.resolve()
     }
 
-    // endregion
-
     // region Debug
 
     @PluginMethod
@@ -387,14 +446,15 @@ class OneSignalCapacitorPlugin : Plugin(),
     @PluginMethod
     fun permissionNative(call: PluginCall) {
         val ret = JSObject()
-        ret.put("permission", if (OneSignal.Notifications.permission) 2 else 1)
+        val status = if (OneSignal.Notifications.permission) PERMISSION_AUTHORIZED else PERMISSION_DENIED
+        ret.put("permission", status)
         call.resolve(ret)
     }
 
     @PluginMethod
     fun requestPermission(call: PluginCall) {
         val fallback = call.getBoolean("fallbackToSettings") ?: false
-        CoroutineScope(Dispatchers.Main).launch {
+        pluginScope.launch {
             val accepted = OneSignal.Notifications.requestPermission(fallback)
             val ret = JSObject()
             ret.put("permission", accepted)
@@ -411,8 +471,12 @@ class OneSignalCapacitorPlugin : Plugin(),
 
     @PluginMethod
     fun registerForProvisionalAuthorization(call: PluginCall) {
+        // Provisional authorization is an iOS-only concept (UNUserNotification
+        // .provisional). Android has no equivalent quiet-delivery permission
+        // tier, so report `accepted = false` rather than misleading the JS
+        // layer into thinking a quiet permission was granted.
         val ret = JSObject()
-        ret.put("accepted", true)
+        ret.put("accepted", false)
         call.resolve(ret)
     }
 
@@ -467,12 +531,15 @@ class OneSignalCapacitorPlugin : Plugin(),
             call.reject("notificationId is required")
             return
         }
-        val event = notificationWillDisplayCache[notificationId]
+        // JS always dispatches this after the listener loop, even when a
+        // listener already called display(). Missing entry = already handled.
+        val event = notificationWillDisplayCache.remove(notificationId)
         if (event == null) {
-            call.reject("Could not find notification will display event")
+            preventDefaultCache.remove(notificationId)
+            call.resolve()
             return
         }
-        if (!preventDefaultCache.contains(notificationId)) {
+        if (!preventDefaultCache.remove(notificationId)) {
             event.notification.display()
         }
         call.resolve()
@@ -485,11 +552,13 @@ class OneSignalCapacitorPlugin : Plugin(),
             call.reject("notificationId is required")
             return
         }
-        val event = notificationWillDisplayCache[notificationId]
+        val event = notificationWillDisplayCache.remove(notificationId)
         if (event == null) {
-            call.reject("Could not find notification will display event")
+            preventDefaultCache.remove(notificationId)
+            call.resolve()
             return
         }
+        preventDefaultCache.remove(notificationId)
         event.notification.display()
         call.resolve()
     }
@@ -588,7 +657,7 @@ class OneSignalCapacitorPlugin : Plugin(),
 
     @PluginMethod
     fun requestLocationPermission(call: PluginCall) {
-        CoroutineScope(Dispatchers.Main).launch {
+        pluginScope.launch {
             OneSignal.Location.requestPermission()
             call.resolve()
         }
@@ -610,7 +679,9 @@ class OneSignalCapacitorPlugin : Plugin(),
 
     // endregion
 
-    // region Live Activities (no-op on Android)
+    // region Live Activities
+    // iOS-only feature; methods below are no-ops on Android so cross-platform
+    // JS code can call them unconditionally. No warnings — silent success.
 
     @PluginMethod
     fun enterLiveActivity(call: PluginCall) {
@@ -647,6 +718,10 @@ class OneSignalCapacitorPlugin : Plugin(),
     // region Observer Callbacks
 
     override fun onWillDisplay(event: INotificationWillDisplayEvent) {
+        // No retainUntilConsumed needed: foreground will-display only fires
+        // while the app is foregrounded, so the JS layer's listener is
+        // already attached. Contrast with onClick() below, which can fire
+        // before the WebView finishes booting on a cold-start tap.
         val notificationId = event.notification.notificationId ?: return
         notificationWillDisplayCache[notificationId] = event
         event.preventDefault()
@@ -654,17 +729,11 @@ class OneSignalCapacitorPlugin : Plugin(),
     }
 
     override fun onClick(event: INotificationClickEvent) {
-        if (bridge != null) {
-            val ret = JSObject()
-            val clickResult = JSObject()
-            clickResult.put("actionId", event.result.actionId)
-            clickResult.put("url", event.result.url)
-            ret.put("result", clickResult)
-            ret.put("notification", serializeNotification(event.notification))
-            notifyListeners("notificationClick", ret)
-        } else {
-            pendingClickEvent = event
-        }
+        // retainUntilConsumed lets Capacitor hold this event until the JS-side
+        // click listener attaches. On Android the OneSignal SDK can deliver a
+        // cold-start click before the WebView has finished booting and the JS
+        // layer has called addEventListener('click', ...).
+        notifyListeners("notificationClick", buildClickEventJson(event), true)
     }
 
     private fun serializeNotification(notification: INotification): JSObject {

package/dist/index.d.ts

@@ -366,6 +366,7 @@ interface PushSubscriptionChangedState {
 declare class PushSubscription implements OneSignalPushSubscriptionAPI {
   private _plugin;
   private _subscriptionObserverList;
+  private _hasRegisteredChangeListener;
   constructor(plugin: OneSignalCapacitorPlugin);
   private _processFunctionList;
   /**
@@ -388,8 +389,9 @@ declare class PushSubscription implements OneSignalPushSubscriptionAPI {
   getOptedInAsync(): Promise<boolean>;
   /**
    * Add a callback that fires when the OneSignal push subscription state changes.
-   * @param  {(event: PushSubscriptionChangedState)=>void} listener
-   * @returns void
+   * The bridge subscription is registered once per namespace instance; subsequent
+   * subscribers append to the local list to avoid orphaned bridge handlers
+   * across hot-reload cycles.
    */
   addEventListener(_event: 'change', listener: (event: PushSubscriptionChangedState) => void): void;
   /**
@@ -474,6 +476,7 @@ declare class User implements OneSignalUserAPI {
   pushSubscription: PushSubscription;
   private _plugin;
   private _userStateObserverList;
+  private _hasRegisteredChangeListener;
   constructor(plugin: OneSignalCapacitorPlugin);
   private _processFunctionList;
   /**
@@ -565,8 +568,9 @@ declare class User implements OneSignalUserAPI {
   }>;
   /**
    * Add a callback that fires when the OneSignal User state changes.
-   * @param  {(event: UserChangedState)=>void} listener
-   * @returns void
+   * The bridge subscription is registered once per namespace instance; subsequent
+   * subscribers append to the local list to avoid orphaned bridge handlers
+   * across hot-reload cycles.
    */
   addEventListener(_event: 'change', listener: (event: UserChangedState) => void): void;
   /**
@@ -804,13 +808,19 @@ declare class InAppMessages implements OneSignalInAppMessagesAPI {
   private _didDisplayInAppMessageListeners;
   private _willDismissInAppMessageListeners;
   private _didDismissInAppMessageListeners;
+  private _hasRegisteredClickListener;
+  private _hasRegisteredWillDisplayListener;
+  private _hasRegisteredDidDisplayListener;
+  private _hasRegisteredWillDismissListener;
+  private _hasRegisteredDidDismissListener;
   constructor(plugin: OneSignalCapacitorPlugin);
   private _processFunctionList;
   /**
    * Add event listeners for In-App Message click and/or lifecycle events.
-   * @param event
-   * @param listener
-   * @returns
+   * Each native event channel is bridged once per namespace instance; subsequent
+   * subscribers are appended to the local list. Without this guard, hot-reload
+   * cycles and effect re-runs leak orphaned bridge subscriptions that fan a
+   * single native event into N JS callbacks.
    */
   addEventListener<K extends InAppMessageEventName>(event: K, listener: (event: InAppMessageEventTypeMap[K]) => void): void;
   /**

package/dist/index.js

@@ -62,6 +62,11 @@ var InAppMessages = class {
 		this._didDisplayInAppMessageListeners = [];
 		this._willDismissInAppMessageListeners = [];
 		this._didDismissInAppMessageListeners = [];
+		this._hasRegisteredClickListener = false;
+		this._hasRegisteredWillDisplayListener = false;
+		this._hasRegisteredDidDisplayListener = false;
+		this._hasRegisteredWillDismissListener = false;
+		this._hasRegisteredDidDismissListener = false;
 		this._plugin = plugin;
 	}
 	_processFunctionList(array, param) {
@@ -69,36 +74,52 @@ var InAppMessages = class {
 	}
 	/**
 	* Add event listeners for In-App Message click and/or lifecycle events.
-	* @param event
-	* @param listener
-	* @returns
+	* Each native event channel is bridged once per namespace instance; subsequent
+	* subscribers are appended to the local list. Without this guard, hot-reload
+	* cycles and effect re-runs leak orphaned bridge subscriptions that fan a
+	* single native event into N JS callbacks.
 	*/
 	addEventListener(event, listener) {
 		if (event === "click") {
 			this._inAppMessageClickListeners.push(listener);
-			this._plugin.addListener("inAppMessageClick", (json) => {
-				this._processFunctionList(this._inAppMessageClickListeners, json);
-			});
+			if (!this._hasRegisteredClickListener) {
+				this._hasRegisteredClickListener = true;
+				this._plugin.addListener("inAppMessageClick", (json) => {
+					this._processFunctionList(this._inAppMessageClickListeners, json);
+				});
+			}
 		} else if (event === "willDisplay") {
 			this._willDisplayInAppMessageListeners.push(listener);
-			this._plugin.addListener("inAppMessageWillDisplay", (event) => {
-				this._processFunctionList(this._willDisplayInAppMessageListeners, event);
-			});
+			if (!this._hasRegisteredWillDisplayListener) {
+				this._hasRegisteredWillDisplayListener = true;
+				this._plugin.addListener("inAppMessageWillDisplay", (event) => {
+					this._processFunctionList(this._willDisplayInAppMessageListeners, event);
+				});
+			}
 		} else if (event === "didDisplay") {
 			this._didDisplayInAppMessageListeners.push(listener);
-			this._plugin.addListener("inAppMessageDidDisplay", (event) => {
-				this._processFunctionList(this._didDisplayInAppMessageListeners, event);
-			});
+			if (!this._hasRegisteredDidDisplayListener) {
+				this._hasRegisteredDidDisplayListener = true;
+				this._plugin.addListener("inAppMessageDidDisplay", (event) => {
+					this._processFunctionList(this._didDisplayInAppMessageListeners, event);
+				});
+			}
 		} else if (event === "willDismiss") {
 			this._willDismissInAppMessageListeners.push(listener);
-			this._plugin.addListener("inAppMessageWillDismiss", (event) => {
-				this._processFunctionList(this._willDismissInAppMessageListeners, event);
-			});
+			if (!this._hasRegisteredWillDismissListener) {
+				this._hasRegisteredWillDismissListener = true;
+				this._plugin.addListener("inAppMessageWillDismiss", (event) => {
+					this._processFunctionList(this._willDismissInAppMessageListeners, event);
+				});
+			}
 		} else if (event === "didDismiss") {
 			this._didDismissInAppMessageListeners.push(listener);
-			this._plugin.addListener("inAppMessageDidDismiss", (event) => {
-				this._processFunctionList(this._didDismissInAppMessageListeners, event);
-			});
+			if (!this._hasRegisteredDidDismissListener) {
+				this._hasRegisteredDidDismissListener = true;
+				this._plugin.addListener("inAppMessageDidDismiss", (event) => {
+					this._processFunctionList(this._didDismissInAppMessageListeners, event);
+				});
+			}
 		}
 	}
 	/**
@@ -544,6 +565,7 @@ var Session = class {
 var PushSubscription = class {
 	constructor(plugin) {
 		this._subscriptionObserverList = [];
+		this._hasRegisteredChangeListener = false;
 		this._plugin = plugin;
 	}
 	_processFunctionList(array, param) {
@@ -575,14 +597,18 @@ var PushSubscription = class {
 	}
 	/**
 	* Add a callback that fires when the OneSignal push subscription state changes.
-	* @param  {(event: PushSubscriptionChangedState)=>void} listener
-	* @returns void
+	* The bridge subscription is registered once per namespace instance; subsequent
+	* subscribers append to the local list to avoid orphaned bridge handlers
+	* across hot-reload cycles.
 	*/
 	addEventListener(_event, listener) {
 		this._subscriptionObserverList.push(listener);
-		this._plugin.addListener("pushSubscriptionChange", (state) => {
-			this._processFunctionList(this._subscriptionObserverList, state);
-		});
+		if (!this._hasRegisteredChangeListener) {
+			this._hasRegisteredChangeListener = true;
+			this._plugin.addListener("pushSubscriptionChange", (state) => {
+				this._processFunctionList(this._subscriptionObserverList, state);
+			});
+		}
 	}
 	/**
 	* Remove a push subscription observer that has been previously added.
@@ -612,6 +638,7 @@ var PushSubscription = class {
 var User = class {
 	constructor(plugin) {
 		this._userStateObserverList = [];
+		this._hasRegisteredChangeListener = false;
 		this._plugin = plugin;
 		this.pushSubscription = new PushSubscription(plugin);
 	}
@@ -737,14 +764,18 @@ var User = class {
 	}
 	/**
 	* Add a callback that fires when the OneSignal User state changes.
-	* @param  {(event: UserChangedState)=>void} listener
-	* @returns void
+	* The bridge subscription is registered once per namespace instance; subsequent
+	* subscribers append to the local list to avoid orphaned bridge handlers
+	* across hot-reload cycles.
 	*/
 	addEventListener(_event, listener) {
 		this._userStateObserverList.push(listener);
-		this._plugin.addListener("userStateChange", (state) => {
-			this._processFunctionList(this._userStateObserverList, state);
-		});
+		if (!this._hasRegisteredChangeListener) {
+			this._hasRegisteredChangeListener = true;
+			this._plugin.addListener("userStateChange", (state) => {
+				this._processFunctionList(this._userStateObserverList, state);
+			});
+		}
 	}
 	/**
 	* Remove a User State observer that has been previously added.

package/ios/Sources/OSCapacitorLaunchOptions/OSCapacitorLaunchOptions.m

@@ -0,0 +1,89 @@
+#import "OSCapacitorLaunchOptions.h"
+#import <UIKit/UIKit.h>
+#import <UserNotifications/UserNotifications.h>
+#import <objc/runtime.h>
+
+@implementation OSCapacitorLaunchOptions
+
+static NSDictionary *_capturedLaunchOptions = nil;
+static NSMutableArray<UNNotificationResponse *> *_capturedColdStartResponses = nil;
+// Flips to YES the first time consumeColdStartResponses runs (i.e. after the JS
+// layer has called OneSignal.initialize and drained whatever was queued). The
+// swizzle stays installed for the process lifetime, so without this flag every
+// subsequent warm/background tap would be retained in the array forever and
+// _capturedColdStartResponses would grow monotonically. Once consumed, new
+// taps fall through to the host delegate without being captured.
+static BOOL _coldStartResponsesConsumed = NO;
+
++ (void)load {
+    _capturedColdStartResponses = [NSMutableArray array];
+    [[NSNotificationCenter defaultCenter]
+        addObserver:self
+           selector:@selector(applicationDidFinishLaunching:)
+               name:UIApplicationDidFinishLaunchingNotification
+             object:nil];
+}
+
++ (void)applicationDidFinishLaunching:(NSNotification *)notification {
+    _capturedLaunchOptions = notification.userInfo;
+
+    [[NSNotificationCenter defaultCenter]
+        removeObserver:self
+                  name:UIApplicationDidFinishLaunchingNotification
+                object:nil];
+
+    // Wrap the UN delegate's didReceiveNotificationResponse so we can hold on
+    // to the UNNotificationResponse iOS hands us on cold start. The OneSignal
+    // iOS SDK drops cold-start responses inside processNotificationResponse:
+    // when no appId is set yet, which is always true on cold start because the
+    // JS layer has not called OneSignal.initialize yet. The plugin replays the
+    // captured response after initialize() so the SDK can fire its click
+    // listeners normally.
+    id unDelegate = [UNUserNotificationCenter currentNotificationCenter].delegate;
+    if (!unDelegate) return;
+
+    SEL didReceiveSel = NSSelectorFromString(@"userNotificationCenter:didReceiveNotificationResponse:withCompletionHandler:");
+    Class delegateClass = [unDelegate class];
+    Method original = class_getInstanceMethod(delegateClass, didReceiveSel);
+    if (!original) return;
+
+    __block IMP originalIMP = method_getImplementation(original);
+    IMP newIMP = imp_implementationWithBlock(^(id self_, UNUserNotificationCenter *center, UNNotificationResponse *response, void (^completionHandler)(void)) {
+        // Queue every response that arrives before the JS layer drains us.
+        // The JS bundle can take multiple seconds to load on cold start (worse
+        // in dev builds), and the user can tap a second notification from the
+        // shade in that window. Overwriting would silently lose the earlier
+        // tap. consumeColdStartResponses clears the queue and flips the
+        // _coldStartResponsesConsumed flag once initialize() has handed every
+        // response to OSNotificationsManager; from that point on, taps fall
+        // straight through to the host delegate so the array can't grow.
+        if (!_coldStartResponsesConsumed) {
+            [_capturedColdStartResponses addObject:response];
+        }
+        ((void(*)(id, SEL, UNUserNotificationCenter*, UNNotificationResponse*, void(^)(void)))originalIMP)(self_, didReceiveSel, center, response, completionHandler);
+    });
+
+    // Try to add the method to the delegate's exact class first. If it succeeds,
+    // the IMP came from a parent class (inherited) and we've safely shadowed it
+    // on this subclass only, leaving sibling subclasses untouched. If it fails,
+    // the method is owned by this exact class and method_setImplementation is
+    // safe — it won't leak the wrap up the inheritance chain.
+    if (!class_addMethod(delegateClass, didReceiveSel, newIMP, method_getTypeEncoding(original))) {
+        method_setImplementation(original, newIMP);
+    }
+}
+
++ (NSDictionary *)launchOptions {
+    return _capturedLaunchOptions;
+}
+
++ (NSArray<UNNotificationResponse *> *)pendingColdStartResponses {
+    return [_capturedColdStartResponses copy];
+}
+
++ (void)consumeColdStartResponses {
+    _coldStartResponsesConsumed = YES;
+    [_capturedColdStartResponses removeAllObjects];
+}
+
+@end

package/ios/Sources/OSCapacitorLaunchOptions/include/OSCapacitorLaunchOptions.h

@@ -0,0 +1,35 @@
+#import <Foundation/Foundation.h>
+#import <UserNotifications/UserNotifications.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// Captures cold-start state from iOS that the OneSignal SDK would otherwise
+/// drop because its JS-driven initialize() runs too late.
+///
+/// This class subscribes to UIApplicationDidFinishLaunchingNotification from
+/// +load (executed by dyld at process start, before main()) so:
+///   * launchOptions are captured before any other code can lose them, and
+///   * the UNUserNotificationCenter delegate's
+///     didReceiveNotificationResponse: is wrapped so we can hold on to the
+///     UNNotificationResponse for a cold-start tap. The OneSignal iOS SDK
+///     drops it inside processNotificationResponse: when no appId is set
+///     yet (OSNotificationsManager.m). We replay it after the JS layer
+///     finishes calling OneSignal.initialize.
+@interface OSCapacitorLaunchOptions : NSObject
+
+@property (class, readonly, nullable) NSDictionary *launchOptions;
+
+/// UNNotificationResponses delivered by iOS while the JS layer was still
+/// booting (i.e. before OneSignal.initialize ran and we drained the queue).
+/// Empty for warm starts and after consumeColdStartResponses has been called.
+/// Multiple entries are possible: the user can tap a second notification from
+/// the shade while the JS bundle is still loading, especially in dev builds.
+@property (class, readonly, nonnull) NSArray<UNNotificationResponse *> *pendingColdStartResponses;
+
+/// Mark the captured cold-start responses as consumed so they are not replayed
+/// twice. Call after handing each response off to the OneSignal iOS SDK.
++ (void)consumeColdStartResponses;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/Sources/OneSignalCapacitorPlugin/OneSignalCapacitorPlugin.swift

@@ -2,16 +2,12 @@ import Foundation
 import Capacitor
 import OneSignalFramework
 import OneSignalLiveActivities
+#if SWIFT_PACKAGE
+import OSCapacitorLaunchOptions
+#endif
 
 @objc(OneSignalCapacitorPlugin)
-public class OneSignalCapacitorPlugin: CAPPlugin, CAPBridgedPlugin,
-    OSNotificationPermissionObserver,
-    OSNotificationLifecycleListener,
-    OSNotificationClickListener,
-    OSPushSubscriptionObserver,
-    OSInAppMessageLifecycleListener,
-    OSInAppMessageClickListener,
-    OSUserStateObserver {
+public class OneSignalCapacitorPlugin: CAPPlugin, CAPBridgedPlugin {
 
     public let identifier = "OneSignalCapacitorPlugin"
     public let jsName = "OneSignalCapacitor"
@@ -72,8 +68,28 @@ public class OneSignalCapacitorPlugin: CAPPlugin, CAPBridgedPlugin,
     ]
 
     private var notificationWillDisplayCache = [String: OSNotificationWillDisplayEvent]()
-    private var preventDefaultCache = [String: OSNotificationWillDisplayEvent]()
-    private var pendingClickEvent: OSNotificationClickEvent?
+    private var preventDefaultCache = Set<String>()
+    private var initialized = false
+
+    // Observer/listener forwarder. The iOS SDK strong-retains conformers of
+    // the lifecycle/click protocols (NSMutableArray-backed), so registering
+    // self directly creates a retain cycle that makes deinit unreachable.
+    // The proxy holds a weak ref back to us, so dropping the last external
+    // ref to the plugin lets deinit run and clean up the proxy registration.
+    private var listenerProxy: OneSignalListenerProxy?
+
+    deinit {
+        // Only present after initialize() ran. Removes are idempotent on the
+        // SDK side; we still gate to avoid touching an uninitialized SDK.
+        guard let listenerProxy = listenerProxy else { return }
+        OneSignal.Notifications.removePermissionObserver(listenerProxy)
+        OneSignal.Notifications.removeForegroundLifecycleListener(listenerProxy)
+        OneSignal.Notifications.removeClickListener(listenerProxy)
+        OneSignal.User.pushSubscription.removeObserver(listenerProxy)
+        OneSignal.User.removeObserver(listenerProxy)
+        OneSignal.InAppMessages.removeLifecycleListener(listenerProxy)
+        OneSignal.InAppMessages.removeClickListener(listenerProxy)
+    }
 
     // MARK: - Core
 
@@ -82,21 +98,56 @@ public class OneSignalCapacitorPlugin: CAPPlugin, CAPBridgedPlugin,
             call.reject("appId is required")
             return
         }
-        OneSignalWrapper.sdkType = "capacitor"
-        OneSignalWrapper.sdkVersion = "010000"
-        OneSignal.initialize(appId, withLaunchOptions: nil)
-        OneSignal.Notifications.addPermissionObserver(self)
-        OneSignal.Notifications.addForegroundLifecycleListener(self)
-        OneSignal.Notifications.addClickListener(self)
-        OneSignal.User.pushSubscription.addObserver(self)
-        OneSignal.User.addObserver(self)
-        OneSignal.InAppMessages.addLifecycleListener(self)
-        OneSignal.InAppMessages.addClickListener(self)
 
-        if let pending = pendingClickEvent {
-            sendNotificationClickEvent(pending)
-            pendingClickEvent = nil
+        // initialize() is idempotent: JS may call it multiple times per
+        // plugin instance (effect re-runs, hot reload). The iOS SDK's
+        // listener arrays don't dedupe, so unguarded re-entry would
+        // double-fire foreground/click events.
+        if initialized {
+            call.resolve()
+            return
         }
+        initialized = true
+
+        OneSignalWrapper.sdkType = "capacitor"
+        OneSignalWrapper.sdkVersion = "010003"
+        // OSCapacitorLaunchOptions's +load captures the dictionary from
+        // UIApplicationDidFinishLaunchingNotification at process start (before
+        // main()), so cold-start notification taps that arrive via launchOptions
+        // are still available to the OneSignal iOS SDK when the JS layer
+        // initializes us.
+        OneSignal.initialize(appId, withLaunchOptions: OSCapacitorLaunchOptions.launchOptions)
+
+        // The OneSignal iOS SDK drops cold-start UNNotificationResponse objects
+        // inside processNotificationResponse: when no appId is set yet, which
+        // is always true on cold start because iOS delivers the response before
+        // OneSignal.initialize() runs from JS. OSCapacitorLaunchOptions's
+        // delegate wrap queues every response that arrives in that window so we
+        // can replay them here, in arrival order, after initialize has set the
+        // appId. The queue can hold more than one entry if the user tapped a
+        // second notification from the shade while the JS bundle was loading.
+        for response in OSCapacitorLaunchOptions.pendingColdStartResponses {
+            OSNotificationsManager.processNotificationResponse(response)
+        }
+        // Always consume, even if the queue was empty. consumeColdStartResponses
+        // also flips a one-way flag that tells the swizzle to stop capturing
+        // future taps; without this unconditional call, sessions that cold-start
+        // without a notification tap would never flip the flag and any later
+        // warm/background taps would accumulate in the static array forever.
+        OSCapacitorLaunchOptions.consumeColdStartResponses()
+
+        let proxy = OneSignalListenerProxy()
+        proxy.owner = self
+        listenerProxy = proxy
+
+        OneSignal.Notifications.addPermissionObserver(proxy)
+        OneSignal.Notifications.addForegroundLifecycleListener(proxy)
+        OneSignal.Notifications.addClickListener(proxy)
+        OneSignal.User.pushSubscription.addObserver(proxy)
+        OneSignal.User.addObserver(proxy)
+        OneSignal.InAppMessages.addLifecycleListener(proxy)
+        OneSignal.InAppMessages.addClickListener(proxy)
+
         call.resolve()
     }
 
@@ -320,7 +371,7 @@ public class OneSignalCapacitorPlugin: CAPPlugin, CAPBridgedPlugin,
             return
         }
         event.preventDefault()
-        preventDefaultCache[notificationId] = event
+        preventDefaultCache.insert(notificationId)
         call.resolve()
     }
 
@@ -329,11 +380,15 @@ public class OneSignalCapacitorPlugin: CAPPlugin, CAPBridgedPlugin,
             call.reject("notificationId is required")
             return
         }
-        guard let event = notificationWillDisplayCache[notificationId] else {
-            call.reject("Could not find notification will display event")
+        // JS always dispatches this after the listener loop, even when a
+        // listener already called display(). Missing entry = already handled.
+        guard let event = notificationWillDisplayCache.removeValue(forKey: notificationId) else {
+            preventDefaultCache.remove(notificationId)
+            call.resolve()
             return
         }
-        if preventDefaultCache[notificationId] == nil {
+        let wasPrevented = preventDefaultCache.remove(notificationId) != nil
+        if !wasPrevented {
             event.notification.display()
         }
         call.resolve()
@@ -344,10 +399,12 @@ public class OneSignalCapacitorPlugin: CAPPlugin, CAPBridgedPlugin,
             call.reject("notificationId is required")
             return
         }
-        guard let event = notificationWillDisplayCache[notificationId] else {
-            call.reject("Could not find notification will display event")
+        guard let event = notificationWillDisplayCache.removeValue(forKey: notificationId) else {
+            preventDefaultCache.remove(notificationId)
+            call.resolve()
             return
         }
+        preventDefaultCache.remove(notificationId)
         event.notification.display()
         call.resolve()
     }
@@ -569,18 +626,16 @@ public class OneSignalCapacitorPlugin: CAPPlugin, CAPBridgedPlugin,
     }
 
     public func onClick(event: OSNotificationClickEvent) {
-        if bridge != nil {
-            sendNotificationClickEvent(event)
-        } else {
-            pendingClickEvent = event
-        }
-    }
-
-    private func sendNotificationClickEvent(_ event: OSNotificationClickEvent) {
-        if let data = event.stringify().data(using: .utf8),
-           let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any] {
-            notifyListeners("notificationClick", data: json)
+        // retainUntilConsumed lets Capacitor hold this event until a JS click
+        // listener attaches. On cold start the plugin's initialize() replays
+        // the OneSignal click before JS has had a chance to call
+        // addEventListener('click', ...), so without this a cold-start tap
+        // would fire before any JS listener exists and be lost.
+        guard let data = event.stringify().data(using: .utf8),
+              let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any] else {
+            return
         }
+        notifyListeners("notificationClick", data: json, retainUntilConsumed: true)
     }
 
     @objc(onWillDisplayInAppMessage:)
@@ -637,3 +692,66 @@ public class OneSignalCapacitorPlugin: CAPPlugin, CAPBridgedPlugin,
         ])
     }
 }
+
+// Forwarding proxy for the OneSignal iOS SDK observer/listener APIs.
+// Registered with the SDK in place of the plugin so the SDK's strong
+// retention of click/lifecycle listeners (NSMutableArray-backed) does not
+// pin the plugin and make its deinit unreachable. The proxy holds a weak
+// ref back to the plugin; once external holders drop the plugin its
+// deinit runs, removes the proxy from the SDK, and the proxy is then
+// released too.
+final class OneSignalListenerProxy: NSObject,
+    OSNotificationPermissionObserver,
+    OSNotificationLifecycleListener,
+    OSNotificationClickListener,
+    OSPushSubscriptionObserver,
+    OSInAppMessageLifecycleListener,
+    OSInAppMessageClickListener,
+    OSUserStateObserver {
+
+    weak var owner: OneSignalCapacitorPlugin?
+
+    public func onNotificationPermissionDidChange(_ permission: Bool) {
+        owner?.onNotificationPermissionDidChange(permission)
+    }
+
+    public func onPushSubscriptionDidChange(state: OSPushSubscriptionChangedState) {
+        owner?.onPushSubscriptionDidChange(state: state)
+    }
+
+    public func onUserStateDidChange(state: OSUserChangedState) {
+        owner?.onUserStateDidChange(state: state)
+    }
+
+    public func onWillDisplay(event: OSNotificationWillDisplayEvent) {
+        owner?.onWillDisplay(event: event)
+    }
+
+    public func onClick(event: OSNotificationClickEvent) {
+        owner?.onClick(event: event)
+    }
+
+    @objc(onWillDisplayInAppMessage:)
+    public func onWillDisplay(event: OSInAppMessageWillDisplayEvent) {
+        owner?.onWillDisplay(event: event)
+    }
+
+    @objc(onDidDisplayInAppMessage:)
+    public func onDidDisplay(event: OSInAppMessageDidDisplayEvent) {
+        owner?.onDidDisplay(event: event)
+    }
+
+    @objc(onWillDismissInAppMessage:)
+    public func onWillDismiss(event: OSInAppMessageWillDismissEvent) {
+        owner?.onWillDismiss(event: event)
+    }
+
+    @objc(onDidDismissInAppMessage:)
+    public func onDidDismiss(event: OSInAppMessageDidDismissEvent) {
+        owner?.onDidDismiss(event: event)
+    }
+
+    public func onClick(event: OSInAppMessageClickEvent) {
+        owner?.onClick(event: event)
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onesignal/capacitor-plugin",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "OneSignal is a high volume Push Notification service for mobile apps. This is the pure Capacitor plugin for OneSignal, providing push notifications, in-app messaging, and more.",
   "keywords": [
     "apns",
@@ -56,21 +56,20 @@
     "verify": "vp pack && vp test run && vp lint"
   },
   "devDependencies": {
-    "@capacitor/core": "^7.0.0",
+    "@capacitor/core": "7.0.0",
     "@capacitor/docgen": "^0.2.2",
     "@types/bun": "latest",
     "@vitest/coverage-v8": "^4.1.2",
     "happy-dom": "^20.9.0",
     "typescript": "^5.9.3",
-    "vite": "npm:@voidzero-dev/vite-plus-core@latest",
     "vite-plus": "0.1.20"
   },
   "peerDependencies": {
-    "@capacitor/core": "^7.0.0"
+    "@capacitor/core": ">=7.0.0"
   },
   "overrides": {
-    "vite": "npm:@voidzero-dev/vite-plus-core@latest",
-    "vitest": "npm:@voidzero-dev/vite-plus-test@latest"
+    "vite": "npm:@voidzero-dev/vite-plus-core@0.1.20",
+    "vitest": "npm:@voidzero-dev/vite-plus-test@0.1.20"
   },
   "packageManager": "bun@1.3.13",
   "capacitor": {