fix: [SDK-4814] dedup Live Activity receive receipts per session

A receive receipt for a notificationId was re-sent on later content
updates or app relaunches once the prior request was forgotten on
success, inflating Confirmed Receipts above Delivered. Track sent
notificationIds in an in-memory set, claimed at enqueue, so each is
reported at most once per session, and shorten the unsent-receipt
retry window from 30 to 7 days.

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 {
-    // Keep receive receipts requests for up to 30 days.
-    static let OneMonthInSeconds = TimeInterval(60 * 60 * 24 * 30)
+    // Only pending receipts live here; de-duplication is handled by the executor's confirmedReceiptIds.
+    static let OneWeekInSeconds = TimeInterval(60 * 60 * 24 * 7)
 
     init() {
-        super.init(cacheKey: OS_LIVE_ACTIVITIES_EXECUTOR_RECEIVE_RECEIPTS_KEY, ttl: ReceiveReceiptsRequestCache.OneMonthInSeconds)
+        super.init(cacheKey: OS_LIVE_ACTIVITIES_EXECUTOR_RECEIVE_RECEIPTS_KEY, ttl: ReceiveReceiptsRequestCache.OneWeekInSeconds)
     }
 }
 
@@ -138,6 +138,8 @@ 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
@@ -172,6 +174,10 @@ 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]
 
@@ -184,6 +190,16 @@ 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,6 +36,7 @@ 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
 
     func prepareForExecution() -> Bool {

iOS_SDK/OneSignalSDK/OneSignalLiveActivitiesTests/OSLiveActivitiesExecutorTests.swift

@@ -173,7 +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"))
         XCTAssertEqual(mockClient.executedRequests.count, 1)
         XCTAssertTrue(mockClient.executedRequests[0] == request)
     }
@@ -515,8 +517,50 @@ 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)
         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.
+     */
+    func testReceiveReceiptsNotResentForSameNotificationIdAcrossDeliveryCycles() throws {
+        /* Setup */
+        let mockDispatchQueue = MockDispatchQueue()
+        let mockClient = MockOneSignalClient()
+        OneSignalCoreImpl.setSharedClient(mockClient)
+        OneSignalUserDefaults.initShared().saveString(forKey: OSUD_LEGACY_PLAYER_ID, withValue: "my-subscription-id")
+        OneSignalUserManagerImpl.sharedInstance.start()
+        // Wait for any user setup requests to complete
+        OneSignalCoreMocks.waitForBackgroundThreads(seconds: 0.2)
+        mockClient.reset()
+
+        let request1 = OSRequestLiveActivityReceiveReceipts(key: "my-notification-id", activityType: "my-activity-type", activityId: "my-activity-id")
+        let request2 = OSRequestLiveActivityReceiveReceipts(key: "my-notification-id", activityType: "my-activity-type", activityId: "my-activity-id")
+        mockClient.setMockResponseForRequest(request: String(describing: request1), response: [String: Any]())
+        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)
+        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)
+
+        /* Then */
+        XCTAssertEqual(mockClient.executedRequests.count, 1, "Duplicate receive-receipt must not be sent for the same notificationId across delivery cycles")
+        XCTAssertTrue(mockClient.executedRequests[0] == request1)
+    }
 }