fix: [SDK-4814] persist Live Activity receive-receipt dedup across launches

The in-memory dedup set did not survive app relaunches, so when ActivityKit
re-emits an active activity's content on launch the same notificationId was
reported again. Keep sent receipts in the persisted cache as dedup markers
(shouldForgetWhenSuccessful = false); supersedes == false drops the re-send
and pollPendingRequests skips successful entries, making the cache the single
source of truth. Remove the redundant in-memory set and shorten the receive-
receipts cache TTL from 7 to 3 days. Adds a relaunch regression test.

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: nan-li

iOS_SDK/OneSignalSDK/OneSignalLiveActivities/Source/Executors/OSLiveActivitiesExecutor.swift

@@ -115,11 +115,11 @@ class StartRequestCache: RequestCache {
 }
 
 class ReceiveReceiptsRequestCache: RequestCache {
-    // Only pending receipts live here; de-duplication is handled by the executor's confirmedReceiptIds.
-    static let OneWeekInSeconds = TimeInterval(60 * 60 * 24 * 7)
+    // Sent receipts stay as dedup markers (not only pending retries), so re-emits after relaunch aren't re-sent.
+    static let ThreeDaysInSeconds = TimeInterval(60 * 60 * 24 * 3)
 
     init() {
-        super.init(cacheKey: OS_LIVE_ACTIVITIES_EXECUTOR_RECEIVE_RECEIPTS_KEY, ttl: ReceiveReceiptsRequestCache.OneWeekInSeconds)
+        super.init(cacheKey: OS_LIVE_ACTIVITIES_EXECUTOR_RECEIVE_RECEIPTS_KEY, ttl: ReceiveReceiptsRequestCache.ThreeDaysInSeconds)
     }
 }
 
@@ -138,8 +138,6 @@ class OSLiveActivitiesExecutor: OSPushSubscriptionObserver {
     let startTokens: StartRequestCache = StartRequestCache()
     let receiveReceipts: ReceiveReceiptsRequestCache = ReceiveReceiptsRequestCache()
     let clickEvents: ClickedRequestCache = ClickedRequestCache()
-    // Dedupes receipts per session so duplicate content-update listeners can't over-report.
-    var confirmedReceiptIds: Set<String> = []
 
     // The live activities request dispatch queue, serial.  This synchronizes access to `updateTokens` and `startTokens`.
     private var requestDispatch: OSDispatchQueue
@@ -174,10 +172,6 @@ class OSLiveActivitiesExecutor: OSPushSubscriptionObserver {
 
     func append(_ request: OSLiveActivityRequest) {
         self.requestDispatch.async {
-            if request is OSRequestLiveActivityReceiveReceipts, !self.claimReceipt(request.key) {
-                return
-            }
-
             let cache = self.getCache(request)
             let existingRequest = cache.items[request.key]
 
@@ -190,16 +184,6 @@ class OSLiveActivitiesExecutor: OSPushSubscriptionObserver {
         }
     }
 
-    // False if this notificationId was already claimed this session. Call on requestDispatch.
-    private func claimReceipt(_ notificationId: String) -> Bool {
-        if confirmedReceiptIds.contains(notificationId) {
-            OneSignalLog.onesignalLog(.LL_VERBOSE, message: "OneSignal.LiveActivities duplicate receive receipt not sent for notificationId: \(notificationId)")
-            return false
-        }
-        confirmedReceiptIds.insert(notificationId)
-        return true
-    }
-
     private func pollPendingRequests() {
         OneSignalLog.onesignalLog(.LL_VERBOSE, message: "OneSignal.LiveActivities pollPendingRequests")
 

iOS_SDK/OneSignalSDK/OneSignalLiveActivities/Source/Requests/OSRequestLiveActivityReceiveReceipts.swift

@@ -36,8 +36,8 @@ class OSRequestLiveActivityReceiveReceipts: OneSignalRequest, OSLiveActivityRequ
     var activityType: String
     var activityId: String
     var requestSuccessful: Bool
-    // Forgotten once sent; duplicate suppression is handled by the executor's confirmedReceiptIds.
-    var shouldForgetWhenSuccessful: Bool = true
+    // Kept after success so the persisted cache suppresses re-sends across relaunches.
+    var shouldForgetWhenSuccessful: Bool = false
 
     func prepareForExecution() -> Bool {
         guard let appId = OneSignalIdentifiers.currentAppId else {

iOS_SDK/OneSignalSDK/OneSignalLiveActivitiesTests/OSLiveActivitiesExecutorTests.swift

@@ -173,9 +173,9 @@ final class OSLiveActivitiesExecutorTests: XCTestCase {
         mockDispatchQueue.waitForDispatches(2)
 
         /* Then */
-        // Forgotten from the cache, but its notificationId is remembered so it isn't reported again.
-        XCTAssertEqual(executor.receiveReceipts.items.count, 0)
-        XCTAssertTrue(executor.confirmedReceiptIds.contains("notification-id"))
+        // The sent receipt is kept as a dedup marker so the same notificationId isn't reported again.
+        XCTAssertEqual(executor.receiveReceipts.items.count, 1)
+        XCTAssertTrue(executor.receiveReceipts.items["notification-id"]?.requestSuccessful ?? false)
         XCTAssertEqual(mockClient.executedRequests.count, 1)
         XCTAssertTrue(mockClient.executedRequests[0] == request)
     }
@@ -517,21 +517,19 @@ final class OSLiveActivitiesExecutorTests: XCTestCase {
         mockDispatchQueue.waitForDispatches(3)
 
         /* Then */
-        // request2 is suppressed as a duplicate of request1; the sent receipt is then forgotten.
-        XCTAssertEqual(executor.receiveReceipts.items.count, 0)
+        // request2 is suppressed as a duplicate of request1, which is kept as a dedup marker.
+        XCTAssertEqual(executor.receiveReceipts.items.count, 1)
         XCTAssertEqual(mockClient.executedRequests.count, 1)
         XCTAssertTrue(mockClient.executedRequests[0] == request1)
     }
 
     /**
-     A receive-receipt for a notificationId must be sent at most once per device. This covers the
-     cross-cycle case: unlike `testReceiveReceiptsRequestNotExecutedWithSameNotificationId` (both receipts
-     appended in one cycle), here the first fully completes and is forgotten before the second arrives, so
-     the duplicate is caught by the remembered notificationIds rather than by the request cache.
+     A receive receipt must be sent at most once per device, even across app launches. The second executor
+     reloads the persisted cache with in-memory state gone, simulating a relaunch where ActivityKit re-emits
+     the active activity's current content and the same notificationId is reported again.
      */
-    func testReceiveReceiptsNotResentForSameNotificationIdAcrossDeliveryCycles() throws {
+    func testReceiveReceiptsNotResentForSameNotificationIdAfterRelaunch() throws {
         /* Setup */
-        let mockDispatchQueue = MockDispatchQueue()
         let mockClient = MockOneSignalClient()
         OneSignalCoreImpl.setSharedClient(mockClient)
         OneSignalUserDefaults.initShared().saveString(forKey: OSUD_LEGACY_PLAYER_ID, withValue: "my-subscription-id")
@@ -546,21 +544,21 @@ final class OSLiveActivitiesExecutorTests: XCTestCase {
         mockClient.setMockResponseForRequest(request: String(describing: request2), response: [String: Any]())
 
         /* When */
-        let executor = OSLiveActivitiesExecutor(requestDispatch: mockDispatchQueue)
-
-        // First cycle: receipt is sent, succeeds, is forgotten, and its notificationId is remembered.
-        executor.append(request1)
-        mockDispatchQueue.waitForDispatches(2)
+        // First launch: the receipt is sent and succeeds.
+        let firstLaunch = MockDispatchQueue()
+        let executor1 = OSLiveActivitiesExecutor(requestDispatch: firstLaunch)
+        executor1.append(request1)
+        firstLaunch.waitForDispatches(2)
         XCTAssertEqual(mockClient.executedRequests.count, 1)
-        XCTAssertEqual(executor.receiveReceipts.items.count, 0)
-        XCTAssertTrue(executor.confirmedReceiptIds.contains("my-notification-id"))
 
-        // Second cycle, same notificationId (e.g. another content update / relaunch): a duplicate.
-        executor.append(request2)
-        mockDispatchQueue.waitForDispatches(3)
+        // Relaunch: a fresh executor reloads the persisted cache; ActivityKit re-emits the same content.
+        let secondLaunch = MockDispatchQueue()
+        let executor2 = OSLiveActivitiesExecutor(requestDispatch: secondLaunch)
+        executor2.append(request2)
+        secondLaunch.waitForDispatches(1)
 
         /* Then */
-        XCTAssertEqual(mockClient.executedRequests.count, 1, "Duplicate receive-receipt must not be sent for the same notificationId across delivery cycles")
+        XCTAssertEqual(mockClient.executedRequests.count, 1, "Receive receipt must not be re-sent for the same notificationId after relaunch")
         XCTAssertTrue(mockClient.executedRequests[0] == request1)
     }
 }