Better timeline handling, based on improved rust APIs.

ElementX/Sources/Services/MockRoomProxy.swift

@@ -8,6 +8,7 @@
 import Foundation
 import UIKit
 import Combine
+import MatrixRustSDK
 
 struct MockRoomProxy: RoomProxyProtocol {
     let id = UUID().uuidString
@@ -38,7 +39,7 @@ struct MockRoomProxy: RoomProxyProtocol {
         
     }
     
-    func paginateBackwards(start: UInt, finish: UInt) {
+    func paginateBackwards(count: UInt, callback: ((Result<[Message], Error>) -> Void)?) {
         
     }
 }

ElementX/Sources/Services/RoomProxy.swift

@@ -14,6 +14,7 @@ import MatrixRustSDK
 enum RoomProxyError: Error {
     case failedRetrievingDisplayName
     case failedRetrievingAvatar
+    case backwardStreamNotAvailable
 }
 
 private class WeakRoomProxyWrapper: RoomDelegate {
@@ -23,27 +24,32 @@ private class WeakRoomProxyWrapper: RoomDelegate {
         self.roomProxy = roomProxy
     }
     
+    // MARK: - RoomDelegate
+    
     func didReceiveMessage(message: Message) {
         DispatchQueue.main.async {
             self.roomProxy?.appendMessage(message)
         }
     }
-    
-    func didPaginateBackwards(messages: [Message]) {
-        DispatchQueue.main.async {
-            self.roomProxy?.preprendMessages(messages)
-        }
-    }
 }
 
 class RoomProxy: RoomProxyProtocol, Equatable {
     private let room: Room
+    private let processingQueue: DispatchQueue
+    
+    private var backwardStream: BackwardsStreamProtocol?
     
     let callbacks = PassthroughSubject<RoomProxyCallback, Never>()
     
     init(room: Room) {
         self.room = room
-        self.room.setDelegate(delegate: WeakRoomProxyWrapper(roomProxy: self))
+        processingQueue = DispatchQueue(label: "RoomProxyProcessingQueue")
+        
+        processingQueue.async {
+            self.backwardStream = room.startLiveEventListener()
+        }
+        
+        room.setDelegate(delegate: WeakRoomProxyWrapper(roomProxy: self))
     }
     
     var id: String {
@@ -119,13 +125,26 @@ class RoomProxy: RoomProxyProtocol, Equatable {
             }
         }
     }
-    
-    func startLiveEventListener() {
-        room.startLiveEventListener()
-    }
-    
-    func paginateBackwards(start: UInt, finish: UInt) {
-        room.paginateBackwards(from: UInt8(start), to: UInt8(finish))
+        
+    func paginateBackwards(count: UInt, callback: ((Result<[Message], Error>) -> Void)?) {
+        processingQueue.async {
+            guard let backwardStream = self.backwardStream else {
+                DispatchQueue.main.async {
+                    callback?(.failure(RoomProxyError.backwardStreamNotAvailable))
+                }
+                return
+            }
+            
+            let messages = backwardStream.paginateBackwards(count: UInt64(count))
+            
+            DispatchQueue.main.async {                
+                callback?(.success(messages))
+                
+                if self.lastMessage == nil {
+                    self.lastMessage = messages.last?.content()
+                }
+            }
+        }
     }
     
     // MARK: - Equatable
@@ -137,11 +156,7 @@ class RoomProxy: RoomProxyProtocol, Equatable {
     // MARK: - Private
     
     fileprivate func preprendMessages(_ messages: [Message]) {
-        if lastMessage == nil {
-            lastMessage = messages.last?.content()
-        }
         
-        callbacks.send(.prependedMessages(messages))
     }
     
     fileprivate func appendMessage(_ message: Message) {

ElementX/Sources/Services/RoomProxyProtocol.swift

@@ -10,7 +10,6 @@ import Combine
 import MatrixRustSDK
 
 enum RoomProxyCallback {
-    case prependedMessages([Message])
     case addedMessage(Message)
     case updatedLastMessage
 }
@@ -32,8 +31,7 @@ protocol RoomProxyProtocol {
     func loadDisplayName(_ completion: @escaping (Result<String, Error>) -> Void)
     func loadAvatar(_ completion: @escaping (Result<UIImage?, Error>) -> Void)
     
-    func startLiveEventListener()
-    func paginateBackwards(start: UInt, finish: UInt)
+    func paginateBackwards(count: UInt, callback: ((Result<[Message], Error>) -> Void)?)
     
     var callbacks: PassthroughSubject<RoomProxyCallback, Never> { get }
 }

ElementX/Sources/Services/Timeline/RoomTimelineProvider.swift

@@ -19,7 +19,6 @@ class RoomTimelineProvider {
     private var cancellables = Set<AnyCancellable>()
     
     private var paginationCounter: UInt = 0
-    private var isWaitingPaginationResponse = false
     
     let callbacks = PassthroughSubject<RoomTimelineCallback, Never>()
     private(set) var messages = [Message]()
@@ -27,17 +26,12 @@ class RoomTimelineProvider {
     init(roomProxy: RoomProxyProtocol) {
         self.roomProxy = roomProxy
         
-        self.roomProxy.startLiveEventListener()
-        
         self.roomProxy.callbacks.sink { [weak self] callback in
             guard let self = self else { return }
             
             switch callback {
             case .addedMessage(let message):
                 self.messages.append(message)
-            case .prependedMessages(let messages):
-                self.messages.insert(contentsOf: messages.reversed(), at: 0)
-                self.isWaitingPaginationResponse = false
             case .updatedLastMessage:
                 break
             }
@@ -48,14 +42,15 @@ class RoomTimelineProvider {
     }
     
     func paginateBackwards(_ count: UInt) {
-        if isWaitingPaginationResponse {
-            return
+        self.roomProxy.paginateBackwards(count: count) { result in
+            switch result {
+            case .success(let messages):
+                self.messages.insert(contentsOf: messages.reversed(), at: 0)
+                self.callbacks.send(.updatedMessages)
+            case .failure(let error):
+                MXLog.debug("Failed paginating backwards with error: \(error)")
+                self.callbacks.send(.updatedMessages)
+            }
         }
-        
-        self.roomProxy.paginateBackwards(start: paginationCounter, finish: count)
-        isWaitingPaginationResponse = true
-        
-        // This is not in any way correct but it will do for now.
-        self.paginationCounter += count
     }
 }