Polls history (#2244)

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

@@ -31,6 +31,7 @@ class MockRoomTimelineController: RoomTimelineControllerProtocol {
     let callbacks = PassthroughSubject<RoomTimelineControllerCallback, Never>()
     
     var timelineItems: [RoomTimelineItemProtocol] = RoomTimelineItemFixtures.default
+    var timelineItemsTimestamp: [TimelineItemIdentifier: Date] = [:]
     
     private var client: UITestsSignalling.Client?
     
@@ -43,7 +44,12 @@ class MockRoomTimelineController: RoomTimelineControllerProtocol {
             fatalError("Failure setting up signalling: \(error)")
         }
     }
-    
+
+    func paginateBackwards(requestSize: UInt) async -> Result<Void, RoomTimelineControllerError> {
+        try? await simulateBackPagination()
+        return .success(())
+    }
+
     func paginateBackwards(requestSize: UInt, untilNumberOfItems: UInt) async -> Result<Void, RoomTimelineControllerError> {
         callbacks.send(.canBackPaginate(false))
         return .success(())
@@ -99,6 +105,10 @@ class MockRoomTimelineController: RoomTimelineControllerProtocol {
         await roomProxy?.timeline.cancelSend(transactionID: transactionID)
     }
     
+    func eventTimestamp(for itemID: TimelineItemIdentifier) -> Date? {
+        timelineItemsTimestamp[itemID] ?? .now
+    }
+    
     // MARK: - UI Test signalling
     
     /// The cancellable used for UI Tests signalling.
@@ -153,6 +163,7 @@ class MockRoomTimelineController: RoomTimelineControllerProtocol {
         timelineItems.insert(contentsOf: newItems, at: 0)
         callbacks.send(.updatedTimelineItems)
         callbacks.send(.isBackPaginating(false))
+        callbacks.send(.canBackPaginate(!backPaginationResponses.isEmpty))
         
         try client?.send(.success)
     }

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

@@ -69,6 +69,18 @@ class RoomTimelineController: RoomTimelineControllerProtocol {
         NotificationCenter.default.addObserver(self, selector: #selector(contentSizeCategoryDidChange), name: UIContentSizeCategory.didChangeNotification, object: nil)
     }
     
+    func paginateBackwards(requestSize: UInt) async -> Result<Void, RoomTimelineControllerError> {
+        MXLog.info("Started back pagination request")
+        switch await roomProxy.timeline.paginateBackwards(requestSize: requestSize) {
+        case .success:
+            MXLog.info("Finished back pagination request")
+            return .success(())
+        case .failure(let error):
+            MXLog.error("Failed back pagination request with error: \(error)")
+            return .failure(.generic)
+        }
+    }
+    
     func paginateBackwards(requestSize: UInt, untilNumberOfItems: UInt) async -> Result<Void, RoomTimelineControllerError> {
         MXLog.info("Started back pagination request")
         switch await roomProxy.timeline.paginateBackwards(requestSize: requestSize, untilNumberOfItems: untilNumberOfItems) {
@@ -236,7 +248,7 @@ class RoomTimelineController: RoomTimelineControllerProtocol {
     
     private func updateTimelineItems() {
         var newTimelineItems = [RoomTimelineItemProtocol]()
-        var canBackPaginate = true
+        var canBackPaginate = !roomProxy.timeline.timelineStartReached
         var isBackPaginating = false
         var lastEncryptedHistoryItemIndex: Int?
         
@@ -299,7 +311,7 @@ class RoomTimelineController: RoomTimelineControllerProtocol {
                 break
             }
         }
-
+        
         timelineItems = newTimelineItems
         
         callbacks.send(.updatedTimelineItems)
@@ -384,4 +396,20 @@ class RoomTimelineController: RoomTimelineControllerProtocol {
             break
         }
     }
+    
+    func eventTimestamp(for itemID: TimelineItemIdentifier) -> Date? {
+        for itemProxy in roomProxy.timeline.timelineProvider.itemProxies {
+            switch itemProxy {
+            case .event(let eventTimelineItemProxy):
+                if eventTimelineItemProxy.id == itemID {
+                    return eventTimelineItemProxy.timestamp
+                }
+            case .virtual:
+                break
+            case .unknown:
+                break
+            }
+        }
+        return nil
+    }
 }

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

@@ -45,6 +45,8 @@ protocol RoomTimelineControllerProtocol {
     
     func processItemDisappearance(_ itemID: TimelineItemIdentifier) async
     
+    func paginateBackwards(requestSize: UInt) async -> Result<Void, RoomTimelineControllerError>
+    
     func paginateBackwards(requestSize: UInt, untilNumberOfItems: UInt) async -> Result<Void, RoomTimelineControllerError>
     
     func sendReadReceipt(for itemID: TimelineItemIdentifier) async -> Result<Void, RoomTimelineControllerError>
@@ -70,6 +72,8 @@ protocol RoomTimelineControllerProtocol {
     func retrySending(itemID: TimelineItemIdentifier) async
     
     func cancelSending(itemID: TimelineItemIdentifier) async
+    
+    func eventTimestamp(for itemID: TimelineItemIdentifier) -> Date?
 }
 
 extension RoomTimelineControllerProtocol {

ElementX/Sources/Services/Timeline/TimelineProxy.swift

@@ -34,6 +34,8 @@ final class TimelineProxy: TimelineProxyProtocol {
    
     private let backPaginationStateSubject = PassthroughSubject<BackPaginationStatus, Never>()
     private let timelineUpdatesSubject = PassthroughSubject<[TimelineDiff], Never>()
+   
+    private(set) var timelineStartReached = false
     
     private let actionsSubject = PassthroughSubject<TimelineProxyAction, Never>()
     var actions: AnyPublisher<TimelineProxyAction, Never> {
@@ -134,6 +136,18 @@ final class TimelineProxy: TimelineProxyProtocol {
         try? timeline.getTimelineEventContentByEventId(eventId: eventID)
     }
     
+    func paginateBackwards(requestSize: UInt) async -> Result<Void, TimelineProxyError> {
+        do {
+            try await Task.dispatch(on: .global()) {
+                try self.timeline.paginateBackwards(opts: .simpleRequest(eventLimit: UInt16(requestSize), waitForToken: true))
+            }
+            
+            return .success(())
+        } catch {
+            return .failure(.failedPaginatingBackwards)
+        }
+    }
+    
     func paginateBackwards(requestSize: UInt, untilNumberOfItems: UInt) async -> Result<Void, TimelineProxyError> {
         do {
             try await Task.dispatch(on: .global()) {
@@ -480,6 +494,9 @@ final class TimelineProxy: TimelineProxyProtocol {
     
     private func subscribeToBackpagination() {
         let listener = RoomBackpaginationStatusListener { [weak self] status in
+            if status == .timelineStartReached {
+                self?.timelineStartReached = true
+            }
             self?.backPaginationStateSubject.send(status)
         }
         do {

ElementX/Sources/Services/Timeline/TimelineProxyProtocol.swift

@@ -43,6 +43,8 @@ protocol TimelineProxyProtocol {
     
     var timelineProvider: RoomTimelineProviderProtocol { get }
     
+    var timelineStartReached: Bool { get }
+    
     func subscribeForUpdates() async
     
     /// Cancels a failed message given its transaction ID from the timeline
@@ -62,6 +64,8 @@ protocol TimelineProxyProtocol {
     /// Retries sending a failed message given its transaction ID
     func retrySend(transactionID: String) async
     
+    func paginateBackwards(requestSize: UInt) async -> Result<Void, TimelineProxyError>
+    
     func paginateBackwards(requestSize: UInt, untilNumberOfItems: UInt) async -> Result<Void, TimelineProxyError>
     
     func sendAudio(url: URL,