Replay JWT invalidated event to late-registered listeners

fireJwtInvalidated now buffers the externalId under a synchronized
lock when no listeners are subscribed (e.g. during SDK init HYDRATE)
and replays it when the first IUserJwtInvalidatedListener is added.
Clears pending event on user switch (onModelReplaced) to prevent
stale replay.

Author: nan-li

OneSignalSDK/onesignal/core/src/main/java/com/onesignal/user/internal/UserManager.kt

@@ -55,26 +55,45 @@ internal open class UserManager(
     private val jwtInvalidatedAppCallbackScope =
         CoroutineScope(SupervisorJob() + Dispatchers.Default)
 
+    private val jwtInvalidatedLock = Any()
+    private var pendingJwtInvalidatedExternalId: String? = null
+
     fun addJwtInvalidatedListener(listener: IUserJwtInvalidatedListener) {
-        jwtInvalidatedNotifier.subscribe(listener)
+        val pendingExternalId: String?
+        synchronized(jwtInvalidatedLock) {
+            jwtInvalidatedNotifier.subscribe(listener)
+            pendingExternalId = pendingJwtInvalidatedExternalId
+            pendingJwtInvalidatedExternalId = null
+        }
+        pendingExternalId?.let {
+            listener.onUserJwtInvalidated(UserJwtInvalidatedEvent(it))
+        }
     }
 
     fun removeJwtInvalidatedListener(listener: IUserJwtInvalidatedListener) {
         jwtInvalidatedNotifier.unsubscribe(listener)
     }
 
     /**
-     * Schedules [IUserJwtInvalidatedListener] delivery on a background dispatcher so HYDRATE and
-     * operation-repo paths can finish internal work before app code runs.
+     * Fires [IUserJwtInvalidatedListener] to all subscribers asynchronously so the caller
+     * (e.g. OperationRepo) is not blocked by developer code. If no listeners are registered yet
+     * (e.g. during SDK init), stores the externalId so it can be replayed when the first
+     * listener is added via [addJwtInvalidatedListener].
      */
     fun fireJwtInvalidated(externalId: String) {
-        jwtInvalidatedAppCallbackScope.launch {
-            runCatching {
-                jwtInvalidatedNotifier.fire { listener ->
-                    listener.onUserJwtInvalidated(UserJwtInvalidatedEvent(externalId))
+        synchronized(jwtInvalidatedLock) {
+            if (jwtInvalidatedNotifier.hasSubscribers) {
+                jwtInvalidatedAppCallbackScope.launch {
+                    runCatching {
+                        jwtInvalidatedNotifier.fire { listener ->
+                            listener.onUserJwtInvalidated(UserJwtInvalidatedEvent(externalId))
+                        }
+                    }.onFailure {
+                        Logging.warn("Failed to deliver JWT invalidated event for externalId=$externalId", it)
+                    }
                 }
-            }.onFailure {
-                Logging.warn("Failed to deliver JWT invalidated event for externalId=$externalId", it)
+            } else {
+                pendingJwtInvalidatedExternalId = externalId
             }
         }
     }
@@ -297,7 +316,11 @@ internal open class UserManager(
     override fun onModelReplaced(
         model: IdentityModel,
         tag: String,
-    ) { }
+    ) {
+        synchronized(jwtInvalidatedLock) {
+            pendingJwtInvalidatedExternalId = null
+        }
+    }
 
     override fun onModelUpdated(
         args: ModelChangedArgs,

OneSignalSDK/onesignal/core/src/test/java/com/onesignal/user/internal/UserManagerTests.kt

@@ -2,6 +2,7 @@ package com.onesignal.user.internal
 
 import com.onesignal.core.internal.language.ILanguageContext
 import com.onesignal.mocks.MockHelper
+import com.onesignal.user.internal.identity.IdentityModel
 import com.onesignal.user.internal.subscriptions.ISubscriptionManager
 import com.onesignal.user.internal.subscriptions.SubscriptionList
 import io.kotest.assertions.throwables.shouldNotThrow
@@ -15,6 +16,8 @@ import io.mockk.mockk
 import io.mockk.runs
 import io.mockk.slot
 import io.mockk.verify
+import kotlin.reflect.full.memberFunctions
+import kotlin.reflect.jvm.isAccessible
 
 class UserManagerTests : FunSpec({
 
@@ -235,4 +238,27 @@ class UserManagerTests : FunSpec({
             )
         }
     }
+
+    test("onModelReplaced clears pendingJwtInvalidatedExternalId") {
+        // Given
+        val mockSubscriptionManager = mockk<ISubscriptionManager>()
+        val userManager =
+            UserManager(mockSubscriptionManager, MockHelper.identityModelStore(), MockHelper.propertiesModelStore(), MockHelper.customEventController(), MockHelper.languageContext())
+
+        // Fire a JWT invalidated event with no subscribers, so it pends
+        val fireMethod = UserManager::class.memberFunctions.first { it.name == "fireJwtInvalidated" }
+        fireMethod.isAccessible = true
+        fireMethod.call(userManager, "user-alice")
+
+        // Verify pending state is set
+        val pendingField = UserManager::class.java.getDeclaredField("pendingJwtInvalidatedExternalId")
+        pendingField.isAccessible = true
+        pendingField.get(userManager) shouldBe "user-alice"
+
+        // When — user switches (model replaced)
+        userManager.onModelReplaced(IdentityModel(), "test")
+
+        // Then — pending state should be cleared
+        pendingField.get(userManager) shouldBe null
+    }
 })