Automatically retry decryptions in the active room when the app becomes active again just in case the NSE received keys we're not aware of

ElementX/Sources/Mocks/Generated/GeneratedMocks.swift

@@ -14076,44 +14076,44 @@ class TimelineProxyMock: TimelineProxyProtocol {
     }
     //MARK: - retryDecryption
 
-    var retryDecryptionForUnderlyingCallsCount = 0
-    var retryDecryptionForCallsCount: Int {
+    var retryDecryptionSessionIDsUnderlyingCallsCount = 0
+    var retryDecryptionSessionIDsCallsCount: Int {
         get {
             if Thread.isMainThread {
-                return retryDecryptionForUnderlyingCallsCount
+                return retryDecryptionSessionIDsUnderlyingCallsCount
             } else {
                 var returnValue: Int? = nil
                 DispatchQueue.main.sync {
-                    returnValue = retryDecryptionForUnderlyingCallsCount
+                    returnValue = retryDecryptionSessionIDsUnderlyingCallsCount
                 }
 
                 return returnValue!
             }
         }
         set {
             if Thread.isMainThread {
-                retryDecryptionForUnderlyingCallsCount = newValue
+                retryDecryptionSessionIDsUnderlyingCallsCount = newValue
             } else {
                 DispatchQueue.main.sync {
-                    retryDecryptionForUnderlyingCallsCount = newValue
+                    retryDecryptionSessionIDsUnderlyingCallsCount = newValue
                 }
             }
         }
     }
-    var retryDecryptionForCalled: Bool {
-        return retryDecryptionForCallsCount > 0
+    var retryDecryptionSessionIDsCalled: Bool {
+        return retryDecryptionSessionIDsCallsCount > 0
     }
-    var retryDecryptionForReceivedSessionID: String?
-    var retryDecryptionForReceivedInvocations: [String] = []
-    var retryDecryptionForClosure: ((String) async -> Void)?
+    var retryDecryptionSessionIDsReceivedSessionIDs: [String]?
+    var retryDecryptionSessionIDsReceivedInvocations: [[String]?] = []
+    var retryDecryptionSessionIDsClosure: (([String]?) async -> Void)?
 
-    func retryDecryption(for sessionID: String) async {
-        retryDecryptionForCallsCount += 1
-        retryDecryptionForReceivedSessionID = sessionID
+    func retryDecryption(sessionIDs: [String]?) async {
+        retryDecryptionSessionIDsCallsCount += 1
+        retryDecryptionSessionIDsReceivedSessionIDs = sessionIDs
         DispatchQueue.main.async {
-            self.retryDecryptionForReceivedInvocations.append(sessionID)
+            self.retryDecryptionSessionIDsReceivedInvocations.append(sessionIDs)
         }
-        await retryDecryptionForClosure?(sessionID)
+        await retryDecryptionSessionIDsClosure?(sessionIDs)
     }
     //MARK: - paginateBackwards
 

ElementX/Sources/Screens/RoomScreen/RoomScreenViewModel.swift

@@ -196,6 +196,14 @@ class RoomScreenViewModel: RoomScreenViewModelType, RoomScreenViewModelProtocol
             .throttle(for: .milliseconds(100), scheduler: DispatchQueue.main, latest: true)
             .weakAssign(to: \.state.unseenKnockRequests, on: self)
             .store(in: &cancellables)
+
+        NotificationCenter.default.publisher(for: UIApplication.didBecomeActiveNotification)
+            .sink { [weak self] _ in
+                Task {
+                    await self?.roomProxy.timeline.retryDecryption()
+                }
+            }
+            .store(in: &cancellables)
     }
 
     private func processIdentityStatusChanges(_ changes: [IdentityStatusChange]) async {

ElementX/Sources/Screens/Timeline/TimelineInteractionHandler.swift

@@ -158,7 +158,7 @@ class TimelineInteractionHandler {
             MXLog.info("Showing debug info for \(eventTimelineItem.id)")
             actionsSubject.send(.showDebugInfo(debugInfo))
         case .retryDecryption(let sessionID):
-            Task { await timelineController.retryDecryption(for: sessionID) }
+            Task { await timelineController.retryDecryption(sessionIDs: [sessionID]) }
         case .report:
             actionsSubject.send(.displayReportContent(itemID: itemID, senderID: eventTimelineItem.sender.id))
         case .react:

ElementX/Sources/Services/Timeline/TimelineController/MockRoomTimelineController.swift

@@ -139,7 +139,7 @@ class MockRoomTimelineController: RoomTimelineControllerProtocol {
         nil
     }
 
-    func retryDecryption(for sessionID: String) async { }
+    func retryDecryption(sessionIDs: [String]?) async { }
 
     func eventTimestamp(for itemID: TimelineItemIdentifier) -> Date? {
         timelineItemsTimestamp[itemID] ?? .now

ElementX/Sources/Services/Timeline/TimelineController/RoomTimelineController.swift

@@ -356,8 +356,8 @@ class RoomTimelineController: RoomTimelineControllerProtocol {
         return nil
     }
 
-    func retryDecryption(for sessionID: String) async {
-        await activeTimeline.retryDecryption(for: sessionID)
+    func retryDecryption(sessionIDs: [String]?) async {
+        await activeTimeline.retryDecryption(sessionIDs: sessionIDs)
     }
 
     // MARK: - Private

ElementX/Sources/Services/Timeline/TimelineController/RoomTimelineControllerProtocol.swift

@@ -82,7 +82,7 @@ protocol RoomTimelineControllerProtocol {
 
     func sendHandle(for itemID: TimelineItemIdentifier) -> SendHandleProxy?
 
-    func retryDecryption(for sessionID: String) async
+    func retryDecryption(sessionIDs: [String]?) async
 
     func eventTimestamp(for itemID: TimelineItemIdentifier) -> Date?
 }

ElementX/Sources/Services/Timeline/TimelineProxy.swift

@@ -155,12 +155,14 @@ final class TimelineProxy: TimelineProxyProtocol {
         }
     }
 
-    func retryDecryption(for sessionID: String) async {
-        MXLog.info("Retrying decryption for sessionID: \(sessionID)")
+    func retryDecryption(sessionIDs: [String]?) async {
+        let sessionIDs = sessionIDs ?? []
+
+        MXLog.info("Retrying decryption for sessionIDs: \(sessionIDs)")
 
         await Task.dispatch(on: .global()) { [weak self] in
-            self?.timeline.retryDecryption(sessionIds: [sessionID])
-            MXLog.info("Finished retrying decryption for sessionID: \(sessionID)")
+            self?.timeline.retryDecryption(sessionIds: sessionIDs)
+            MXLog.info("Finished retrying decryption for sessionID: \(sessionIDs)")
         }
     }
 

ElementX/Sources/Services/Timeline/TimelineProxyProtocol.swift

@@ -35,7 +35,7 @@ protocol TimelineProxyProtocol {
 
     func messageEventContent(for timelineItemID: TimelineItemIdentifier) async -> RoomMessageEventContentWithoutRelation?
 
-    func retryDecryption(for sessionID: String) async
+    func retryDecryption(sessionIDs: [String]?) async
 
     func paginateBackwards(requestSize: UInt16) async -> Result<Void, TimelineProxyError>
     func paginateForwards(requestSize: UInt16) async -> Result<Void, TimelineProxyError>
@@ -113,3 +113,9 @@ protocol TimelineProxyProtocol {
                                 html: String?,
                                 intentionalMentions: Mentions) -> RoomMessageEventContentWithoutRelation
 }
+
+extension TimelineProxyProtocol {
+    func retryDecryption() async {
+        await retryDecryption(sessionIDs: nil)
+    }
+}