Caching the room proxies and their messages. Improved performance throughout.

ElementX/Sources/Services/Timeline/RoomTimelineController.swift

@@ -35,11 +35,13 @@ class RoomTimelineController: RoomTimelineControllerProtocol {
             guard let self = self else { return }
             
             switch callback {
-            case .addedMessage:
+            case .updatedMessages:
                 self.updateTimelineItems()
             }
         }.store(in: &cancellables)
         
+        updateTimelineItems()
+        
         NotificationCenter.default.addObserver(self, selector: #selector(contentSizeCategoryDidChange), name: UIContentSizeCategory.didChangeNotification, object: nil)
     }
     

ElementX/Sources/Services/Timeline/RoomTimelineProvider.swift

@@ -14,7 +14,6 @@ class RoomTimelineProvider: RoomTimelineProviderProtocol {
     private var cancellables = Set<AnyCancellable>()
     
     let callbacks = PassthroughSubject<RoomTimelineCallback, Never>()
-    private(set) var messages = [RoomMessageProtocol]()
     
     init(roomProxy: RoomProxyProtocol) {
         self.roomProxy = roomProxy
@@ -23,24 +22,24 @@ class RoomTimelineProvider: RoomTimelineProviderProtocol {
             guard let self = self else { return }
             
             switch callback {
-            case .addedMessage(let message):
-                self.messages.append(message)
-                self.callbacks.send(.addedMessage)
-            case .updatedLastMessage:
-                break
+            case .updatedMessages:
+                self.callbacks.send(.updatedMessages)
             }
         }.store(in: &cancellables)
     }
     
-    func paginateBackwards(_ count: UInt, callback: ((Result<([RoomMessageProtocol]), RoomTimelineError>) -> Void)?) {
+    func paginateBackwards(_ count: UInt, callback: ((Result<Void, RoomTimelineError>) -> Void)?) {
         self.roomProxy.paginateBackwards(count: count) { result in
             switch result {
-            case .success(let messages):
-                self.messages.insert(contentsOf: messages.reversed(), at: 0)
-                callback?(.success((self.messages)))
+            case .success:
+                callback?(.success(()))
             case .failure:
                 callback?(.failure(.generic))
             }
         }
     }
+    
+    var messages: [RoomMessageProtocol] {
+        roomProxy.messages
+    }
 }

ElementX/Sources/Services/Timeline/RoomTimelineProviderProtocol.swift

@@ -10,7 +10,7 @@ import Foundation
 import Combine
 
 enum RoomTimelineCallback {
-    case addedMessage
+    case updatedMessages
 }
 
 enum RoomTimelineError: Error {
@@ -22,5 +22,5 @@ protocol RoomTimelineProviderProtocol {
     
     var messages: [RoomMessageProtocol] { get }
     
-    func paginateBackwards(_ count: UInt, callback: ((Result<([RoomMessageProtocol]), RoomTimelineError>) -> Void)?)
+    func paginateBackwards(_ count: UInt, callback: ((Result<Void, RoomTimelineError>) -> Void)?)
 }