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

ElementX/Sources/AppCoordinator.swift

@@ -101,39 +101,31 @@ class AppCoordinator: AuthenticationCoordinatorDelegate, Coordinator {
             fatalError("User session should be already setup at this point")
         }
         
-        showLoadingIndicator()
+        guard let roomProxy = userSession.rooms.first(where: { $0.id == roomIdentifier }) else {
+            MXLog.error("Invalid room identifier: \(roomIdentifier)")
+            return
+        }
         
-        userSession.getRoomList { [weak self] rooms in
+        let memberDetailsProvider = MemberDetailsProvider(roomProxy: roomProxy)
+        
+        let timelineItemFactory = RoomTimelineItemFactory(mediaProvider: userSession.mediaProvider,
+                                                          memberDetailsProvider: memberDetailsProvider,
+                                                          attributedStringBuilder: AttributedStringBuilder())
+        
+        let timelineController = RoomTimelineController(timelineProvider: RoomTimelineProvider(roomProxy: roomProxy),
+                                                        timelineItemFactory: timelineItemFactory,
+                                                        mediaProvider: userSession.mediaProvider,
+                                                        memberDetailsProvider: memberDetailsProvider)
+        
+        let parameters = RoomScreenCoordinatorParameters(timelineController: timelineController,
+                                                         roomName: roomProxy.name)
+        let coordinator = RoomScreenCoordinator(parameters: parameters)
+        
+        self.add(childCoordinator: coordinator)
+        self.navigationRouter.push(coordinator) { [weak self] in
             guard let self = self else { return }
             
-            self.hideLoadingIndicator()
+            self.remove(childCoordinator: coordinator)
-            
-            guard let roomProxy = rooms.filter({ $0.id == roomIdentifier}).first else {
-                MXLog.error("Invalid room identifier: \(roomIdentifier)")
-                return
-            }
-            
-            let memberDetailsProvider = MemberDetailsProvider(roomProxy: roomProxy)
-            
-            let timelineItemFactory = RoomTimelineItemFactory(mediaProvider: userSession.mediaProvider,
-                                                              memberDetailsProvider: memberDetailsProvider,
-                                                              attributedStringBuilder: AttributedStringBuilder())
-            
-            let timelineController = RoomTimelineController(timelineProvider: RoomTimelineProvider(roomProxy: roomProxy),
-                                                            timelineItemFactory: timelineItemFactory,
-                                                            mediaProvider: userSession.mediaProvider,
-                                                            memberDetailsProvider: memberDetailsProvider)
-            
-            let parameters = RoomScreenCoordinatorParameters(timelineController: timelineController,
-                                                             roomName: roomProxy.name)
-            let coordinator = RoomScreenCoordinator(parameters: parameters)
-            
-            self.add(childCoordinator: coordinator)
-            self.navigationRouter.push(coordinator) { [weak self] in
-                guard let self = self else { return }
-                
-                self.remove(childCoordinator: coordinator)
-            }
         }
     }
     

ElementX/Sources/Screens/HomeScreen/HomeScreenCoordinator.swift

@@ -91,8 +91,6 @@ final class HomeScreenCoordinator: Coordinator, Presentable {
     // MARK: - Private
     
     func updateRoomsList() {
-        parameters.userSession.getRoomList { [weak self] rooms in
+        self.viewModel.updateWithRoomList(parameters.userSession.rooms)
-            self?.viewModel.updateWithRoomList(rooms)
-        }
     }
 }

ElementX/Sources/Screens/HomeScreen/HomeScreenViewModel.swift

@@ -67,7 +67,7 @@ class HomeScreenViewModel: HomeScreenViewModelType, HomeScreenViewModelProtocol
         self.roomList = roomList
         
         state.rooms = roomList.map { roomProxy in
-            roomFromProxy(roomProxy)
+            buildRoomFromProxy(roomProxy)
         }
         
         roomUpdateListeners.removeAll()
@@ -75,10 +75,8 @@ class HomeScreenViewModel: HomeScreenViewModelType, HomeScreenViewModelProtocol
         roomList.forEach({ roomProxy  in
             roomProxy.callbacks.sink { [weak self] callback in
                 switch callback {
-                case .updatedLastMessage:
+                case .updatedMessages:
                     self?.loadLastMessageForRoomWithIdentifier(roomProxy.id)
-                default:
-                    break
                 }
             }
             .store(in: &roomUpdateListeners)
@@ -92,9 +90,19 @@ class HomeScreenViewModel: HomeScreenViewModelType, HomeScreenViewModelProtocol
     // MARK: - Private
     
     private func loadRoomDataForIdentifier(_ roomIdentifier: String) {
-        loadAvatarForRoomWithIdentifier(roomIdentifier)
+        let room = state.rooms.first(where: { $0.id == roomIdentifier })
-        loadRoomDisplayNameForRoomWithIdentifier(roomIdentifier)
+        
-        loadLastMessageForRoomWithIdentifier(roomIdentifier)
+        if room?.avatar == nil {
+            loadAvatarForRoomWithIdentifier(roomIdentifier)
+        }
+        
+        if room?.displayName == nil {
+            loadRoomDisplayNameForRoomWithIdentifier(roomIdentifier)
+        }
+        
+        if room?.lastMessage == nil {
+            loadLastMessageForRoomWithIdentifier(roomIdentifier)
+        }
     }
     
     private func loadAvatarForRoomWithIdentifier(_ roomIdentifier: String) {
@@ -149,22 +157,12 @@ class HomeScreenViewModel: HomeScreenViewModelType, HomeScreenViewModelProtocol
             return
         }
         
-        if let lastMessage = room.lastMessage {
+        if let lastMessage = room.messages.last {
-            self.updateLastMessage(lastMessage, forRoomWithIdentifier: roomIdentifier)
+            self.updateLastMessage(lastMessage.body, forRoomWithIdentifier: roomIdentifier)
-        } else {
+            return
-            room.paginateBackwards(count: 1) { result in
-                switch result {
-                case .success(let messages):
-                    guard let lastMessage = messages.last else {
-                        return
-                    }
-                    
-                    self.updateLastMessage(lastMessage.body, forRoomWithIdentifier: roomIdentifier)
-                default:
-                    break
-                }
-            }
         }
+        
+        room.paginateBackwards(count: 1, callback: nil)
     }
     
     private func updateLastMessage(_ lastMessage: String, forRoomWithIdentifier roomIdentifier: String) {
@@ -174,15 +172,18 @@ class HomeScreenViewModel: HomeScreenViewModelType, HomeScreenViewModelProtocol
         
         self.state.rooms[index].lastMessage = lastMessage
     }
+    
+    private func buildRoomFromProxy(_ roomProxy: RoomProxyProtocol) -> HomeScreenRoom {
+        let avatar = mediaProvider.imageForURL(roomProxy.avatarURL)
         
-    private func roomFromProxy(_ roomProxy: RoomProxyProtocol) -> HomeScreenRoom {
+        return HomeScreenRoom(id: roomProxy.id,
-        HomeScreenRoom(id: roomProxy.id,
+                              displayName: roomProxy.name,
-                       displayName: roomProxy.name,
+                              topic: roomProxy.topic,
-                       topic: roomProxy.topic,
+                              lastMessage: roomProxy.messages.last?.body,
-                       lastMessage: roomProxy.lastMessage,
+                              avatar: avatar,
-                       isDirect: roomProxy.isDirect,
+                              isDirect: roomProxy.isDirect,
-                       isEncrypted: roomProxy.isEncrypted,
+                              isEncrypted: roomProxy.isEncrypted,
-                       isSpace: roomProxy.isSpace,
+                              isSpace: roomProxy.isSpace,
-                       isTombstoned: roomProxy.isTombstoned)
+                              isTombstoned: roomProxy.isTombstoned)
     }
 }

ElementX/Sources/Screens/RoomScreen/RoomScreenViewModel.swift

@@ -38,9 +38,7 @@ class RoomScreenViewModel: RoomScreenViewModelType, RoomScreenViewModelProtocol
         self.timelineController = timelineController
         self.timelineViewFactory = timelineViewFactory
         
-        super.init(initialViewState: RoomScreenViewState(roomTitle: roomName ?? "💥"))
+        super.init(initialViewState: RoomScreenViewState(roomTitle: roomName ?? "Unknown room 💥"))
-        
-        buildTimelineViews()
         
         timelineController.callbacks.sink { [weak self] callback in
             guard let self = self else { return }
@@ -57,6 +55,8 @@ class RoomScreenViewModel: RoomScreenViewModelType, RoomScreenViewModelProtocol
                 self.state.items[viewIndex] = timelineViewFactory.buildTimelineViewFor(timelineItem)
             }
         }.store(in: &cancellables)
+        
+        buildTimelineViews()
     }
     
     // MARK: - Public
@@ -80,8 +80,10 @@ class RoomScreenViewModel: RoomScreenViewModelType, RoomScreenViewModelProtocol
     // MARK: - Private
     
     private func buildTimelineViews() {
-        state.items = timelineController.timelineItems.map { item  in
+        let stateItems = timelineController.timelineItems.map { item  in
             timelineViewFactory.buildTimelineViewFor(item)
         }
+        
+        state.items = stateItems
     }
 }

ElementX/Sources/Screens/RoomScreen/View/Timeline/EmoteRoomTimelineView.swift

@@ -30,7 +30,7 @@ struct EmoteRoomTimelineView: View {
 
 struct EmoteRoomTimelineView_Previews: PreviewProvider {
     static var previews: some View {
-        body
+        body.preferredColorScheme(.light)
         body.preferredColorScheme(.dark)
     }
     

ElementX/Sources/Screens/RoomScreen/View/Timeline/EventBasedTimelineView.swift

@@ -51,7 +51,7 @@ struct EventBasedTimelineView: View {
 
 struct EventBasedTimelineView_Previews: PreviewProvider {
     static var previews: some View {
-        body
+        body.preferredColorScheme(.light)
         body.preferredColorScheme(.dark)
     }
     

ElementX/Sources/Screens/RoomScreen/View/Timeline/FormattedBodyText.swift

@@ -35,7 +35,7 @@ struct FormattedBodyText: View {
 
 struct FormattedBodyText_Previews: PreviewProvider {
     static var previews: some View {
-        body
+        body.preferredColorScheme(.light)
         body.preferredColorScheme(.dark)
         
     }

ElementX/Sources/Screens/RoomScreen/View/Timeline/ImageRoomTimelineView.swift

@@ -35,7 +35,7 @@ struct ImageRoomTimelineView: View {
 
 struct ImageRoomTimelineView_Previews: PreviewProvider {
     static var previews: some View {
-        body
+        body.preferredColorScheme(.light)
         body.preferredColorScheme(.dark)
     }
      

ElementX/Sources/Screens/RoomScreen/View/Timeline/NoticeRoomTimelineView.swift

@@ -30,7 +30,7 @@ struct NoticeRoomTimelineView: View {
 
 struct NoticeRoomTimelineView_Previews: PreviewProvider {
     static var previews: some View {
-        body
+        body.preferredColorScheme(.light)
         body.preferredColorScheme(.dark)
     }
     

ElementX/Sources/Screens/RoomScreen/View/Timeline/PlaceholderAvatarImage.swift

@@ -36,7 +36,7 @@ struct PlaceholderAvatarImage: View {
 
 struct PlaceholderAvatarImage_Previews: PreviewProvider {
     static var previews: some View {
-        body
+        body.preferredColorScheme(.light)
         body.preferredColorScheme(.dark)
     }
     

ElementX/Sources/Screens/RoomScreen/View/Timeline/SeparatorRoomTimelineView.swift

@@ -44,7 +44,7 @@ struct LabelledDivider: View {
 
 struct SeparatorRoomTimelineView_Previews: PreviewProvider {
     static var previews: some View {
-        body
+        body.preferredColorScheme(.light)
         body.preferredColorScheme(.dark)
     }
     

ElementX/Sources/Screens/RoomScreen/View/Timeline/TextRoomTimelineView.swift

@@ -27,7 +27,7 @@ struct TextRoomTimelineView: View {
 
 struct TextRoomTimelineView_Previews: PreviewProvider {
     static var previews: some View {
-        body
+        body.preferredColorScheme(.light)
         body.preferredColorScheme(.dark)
     }
     

ElementX/Sources/Screens/RoomScreen/View/TimelineView.swift

@@ -59,9 +59,16 @@ struct TimelineView: View {
                 tableViewObserver = TableViewObserver(tableView: tableView,
                                                       topDetectionOffset: (tableView.bounds.size.height / 3.0))
                 
+                tableViewObserver.scrollToBottom()
+                
                 // Check if there are enough items. Otherwise ask for more
                 attemptBackPagination()
             }
+            .onAppear(perform: {
+                if timelineItems != context.viewState.items {
+                    timelineItems = context.viewState.items
+                }
+            })
             .onReceive(tableViewObserver.scrollViewDidReachTop, perform: {
                 if context.viewState.isBackPaginating {
                     return
@@ -202,6 +209,20 @@ private class TableViewObserver: NSObject, UITableViewDelegate {
         return (scrollView.contentOffset.y + scrollView.adjustedContentInset.top) <= topDetectionOffset
     }
     
+    func scrollToBottom() {
+        guard let tableView = tableView,
+              tableView.numberOfSections > 0  else {
+                  return
+        }
+        
+        let currentItemCount = tableView.numberOfRows(inSection: 0)
+        guard currentItemCount > 1 else {
+            return
+        }
+        
+        tableView.scrollToRow(at: .init(row: currentItemCount - 1, section: 0), at: .bottom, animated: false)
+    }
+    
     // MARK: - UIScrollViewDelegate
 
     func scrollViewDidScroll(_ scrollView: UIScrollView) {

ElementX/Sources/Services/Authentication/UserSession.swift

@@ -32,7 +32,9 @@ private class WeakUserSessionWrapper: ClientDelegate {
 class UserSession: ClientDelegate {
     
     private let client: Client
-    private var rooms: [RoomProxy] = [] {
+    private let processingQueue: DispatchQueue
+    
+    private(set) var rooms: [RoomProxy] = [] {
         didSet {
             self.callbacks.send(.updatedRoomsList)
         }
@@ -48,10 +50,13 @@ class UserSession: ClientDelegate {
     
     init(client: Client) {
         self.client = client
+        self.processingQueue = DispatchQueue(label: "UserSessionProcessingQueue")
         self.mediaProvider = MediaProvider(client: client, imageCache: ImageCache.default)
         
         client.setDelegate(delegate: WeakUserSessionWrapper(userSession: self))
         client.startSync()
+        
+        updateRooms()
     }
     
     var userIdentifier: String {
@@ -81,33 +86,39 @@ class UserSession: ClientDelegate {
         }
     }
     
-    func getRoomList(_ completion: @escaping ([RoomProxyProtocol]) -> Void) {
-        fetchRoomList(completion)
-    }
-    
     // MARK: ClientDelegate
     
     func didReceiveSyncUpdate() {
-        fetchRoomList { [weak self] rooms in
+        updateRooms()
-            guard let self = self else { return }
-            if self.rooms != rooms {
-                self.rooms = rooms
-            }
-        }
-        
-        client.setDelegate(delegate: nil)
     }
     
     // MARK: Private
     
-    func fetchRoomList(_ completion: @escaping ([RoomProxy]) -> Void) {
+    func updateRooms() {
-        DispatchQueue.global(qos: .background).async {
+        var currentRooms = self.rooms
-            let rooms = self.client.rooms().map {
+        self.processingQueue.async { [weak self] in
-                return RoomProxy(room: $0, messageFactory: RoomMessageFactory())
+            guard let self = self else {
+                return
+            }
+            
+            let sdkRooms = self.client.rooms()
+            let diff = sdkRooms.map({ $0.id()}).difference(from: currentRooms.map({ $0.id }))
+            
+            for change in diff {
+                switch change {
+                case .insert(_, let id, _):
+                    guard let sdkRoom = sdkRooms.first(where: { $0.id() == id }) else {
+                        MXLog.error("Failed retrieving sdk room with id: \(id)")
+                        break
+                    }
+                    currentRooms.append(RoomProxy(room: sdkRoom, messageFactory: RoomMessageFactory()))
+                case .remove(_, let id, _):
+                    currentRooms.removeAll { $0.id == id }
+                }
             }
             
             DispatchQueue.main.async {
-                completion(rooms)
+                self.rooms = currentRooms
             }
         }
     }

ElementX/Sources/Services/Media/MediaProvider.swift

@@ -18,7 +18,7 @@ struct MediaProvider: MediaProviderProtocol {
     init(client: Client, imageCache: Kingfisher.ImageCache) {
         self.client = client
         self.imageCache = imageCache
-        self.processingQueue = DispatchQueue(label: "MediaProviderProcessingQueue")
+        self.processingQueue = DispatchQueue(label: "MediaProviderProcessingQueue", attributes: .concurrent)
     }
     
     func imageForURL(_ url: String?) -> UIImage? {

ElementX/Sources/Services/Room/Members/MemberDetailsProvider.swift

@@ -10,7 +10,6 @@ import Foundation
 
 class MemberDetailsProvider: MemberDetailsProviderProtocol {
     private let roomProxy: RoomProxyProtocol?
-    private let processingQueue = DispatchQueue(label: "MemberDetailsProviderProcessingQueue")
     private var memberAvatars = [String: String]()
     private var memberDisplayNames = [String: String]()
     
@@ -31,25 +30,19 @@ class MemberDetailsProvider: MemberDetailsProviderProtocol {
             completion(.success(avatarURL))
         }
         
-        processingQueue.async {
+        roomProxy.avatarURLForUserId(userId, completion: { [weak self] result in
-            roomProxy.avatarURLForUserId(userId, completion: { [weak self] result in
+            guard let self = self else {
-                guard let self = self else {
+                return
-                    return
+            }
-                }
+            
-                
+            switch result {
-                switch result {
+            case .success(let avatarURL):
-                case .success(let avatarURL):
+                self.memberAvatars[userId] = avatarURL
-                    DispatchQueue.main.async {
+                completion(.success(avatarURL))
-                        self.memberAvatars[userId] = avatarURL
+            case .failure:
-                        completion(.success(avatarURL))
+                completion(.failure(.failedRetrievingUserAvatarURL))
-                    }
+            }
-                case .failure:
+        })
-                    DispatchQueue.main.async {
-                        completion(.failure(.failedRetrievingUserAvatarURL))
-                    }
-                }
-            })
-        }
     }
     
     func displayNameForUserId(_ userId: String) -> String? {
@@ -65,24 +58,18 @@ class MemberDetailsProvider: MemberDetailsProviderProtocol {
             completion(.success(avatarURL))
         }
         
-        processingQueue.async {
+        roomProxy.displayNameForUserId(userId, completion: { [weak self] result in
-            roomProxy.displayNameForUserId(userId, completion: { [weak self] result in
+            guard let self = self else {
-                guard let self = self else {
+                return
-                    return
+            }
-                }
+            
-                
+            switch result {
-                switch result {
+            case .success(let displayName):
-                case .success(let displayName):
+                self.memberDisplayNames[userId] = displayName
-                    DispatchQueue.main.async {
+                completion(.success(displayName))
-                        self.memberDisplayNames[userId] = displayName
+            case .failure:
-                        completion(.success(displayName))
+                completion(.failure(.failedRetrievingUserDisplayName))
-                    }
+            }
-                case .failure:
+        })
-                    DispatchQueue.main.async {
-                        completion(.failure(.failedRetrievingUserDisplayName))
-                    }
-                }
-            })
-        }
     }
 }

ElementX/Sources/Services/Room/MockRoomProxy.swift

@@ -15,7 +15,7 @@ struct MockRoomProxy: RoomProxyProtocol {
     let displayName: String
     
     let topic: String? = nil
-    let lastMessage: String? = "Last message" 
+    let messages: [RoomMessageProtocol] = []
     
     let avatarURL: String? = nil
     
@@ -35,7 +35,7 @@ struct MockRoomProxy: RoomProxyProtocol {
         
     }
     
-    func paginateBackwards(count: UInt, callback: ((Result<[RoomMessageProtocol], RoomProxyError>) -> Void)?) {
+    func paginateBackwards(count: UInt, callback: ((Result<Void, RoomProxyError>) -> Void)?) {
         
     }
     

ElementX/Sources/Services/Room/RoomProxy.swift

@@ -27,22 +27,31 @@ private class WeakRoomProxyWrapper: RoomDelegate {
     }
 }
 
-class RoomProxy: RoomProxyProtocol, Equatable {
+class RoomProxy: RoomProxyProtocol {
     private let room: Room
     private let messageFactory: RoomMessageFactory
-    private let processingQueue: DispatchQueue
+    
+    private let generalProcessingQueue: DispatchQueue
+    private let messageProcessingQueue: DispatchQueue
     
     private var backwardStream: BackwardsStreamProtocol?
     
     let callbacks = PassthroughSubject<RoomProxyCallback, Never>()
     
+    private(set) var messages: [RoomMessageProtocol]
+    
     init(room: Room, messageFactory: RoomMessageFactory) {
         self.room = room
         self.messageFactory = messageFactory
-        processingQueue = DispatchQueue(label: "RoomProxyProcessingQueue")
+        generalProcessingQueue = DispatchQueue(label: "RoomProxyGeneralProcessingQueue")
+        messageProcessingQueue = DispatchQueue(label: "RoomProxyMessageProcessingQueue")
+        messages = []
         
-        processingQueue.async {
+        messageProcessingQueue.async {
-            self.backwardStream = room.startLiveEventListener()
+            let backwardStream = room.startLiveEventListener()
+            DispatchQueue.main.async {
+                self.backwardStream = backwardStream
+            }
         }
         
         room.setDelegate(delegate: WeakRoomProxyWrapper(roomProxy: self))
@@ -80,22 +89,12 @@ class RoomProxy: RoomProxyProtocol, Equatable {
         room.isTombstoned()
     }
     
-    var lastMessage: String? {
-        didSet {
-            if lastMessage == oldValue {
-                return
-            }
-            
-            callbacks.send(.updatedLastMessage)
-        }
-    }
-    
     var avatarURL: String? {
         room.avatarUrl()
     }
     
     func avatarURLForUserId(_ userId: String, completion: @escaping (Result<String?, RoomProxyError>) -> Void) {
-        processingQueue.async {
+        generalProcessingQueue.async {
             do {
                 let avatarURL = try self.room.memberAvatarUrl(userId: userId)
                 
@@ -111,10 +110,10 @@ class RoomProxy: RoomProxyProtocol, Equatable {
     }
     
     func displayNameForUserId(_ userId: String, completion: @escaping (Result<String?, RoomProxyError>) -> Void) {
-        processingQueue.async {
+        generalProcessingQueue.async {
             do {
                 let displayName = try self.room.memberDisplayName(userId: userId)
-                
+
                 DispatchQueue.main.async {
                     completion(.success(displayName))
                 }
@@ -127,10 +126,10 @@ class RoomProxy: RoomProxyProtocol, Equatable {
     }
     
     func displayName(_ completion: @escaping (Result<String, RoomProxyError>) -> Void) {
-        processingQueue.async {
+        generalProcessingQueue.async {
             do {
                 let displayName = try self.room.displayName()
-                
+
                 DispatchQueue.main.async {
                     completion(.success(displayName))
                 }
@@ -142,8 +141,8 @@ class RoomProxy: RoomProxyProtocol, Equatable {
         }
     }
             
-    func paginateBackwards(count: UInt, callback: ((Result<[RoomMessageProtocol], RoomProxyError>) -> Void)?) {
+    func paginateBackwards(count: UInt, callback: ((Result<Void, RoomProxyError>) -> Void)?) {
-        processingQueue.async {
+        messageProcessingQueue.async {
             guard let backwardStream = self.backwardStream else {
                 DispatchQueue.main.async {
                     callback?(.failure(.backwardStreamNotAvailable))
@@ -153,29 +152,20 @@ class RoomProxy: RoomProxyProtocol, Equatable {
             
             let messages = backwardStream.paginateBackwards(count: UInt64(count)).map { message in
                 self.messageFactory.buildRoomMessageFrom(message)
-            }
+            }.reversed()
             
             DispatchQueue.main.async {
-                callback?(.success(messages))
+                self.messages.insert(contentsOf: messages, at: 0)
-                if self.lastMessage == nil {
+                callback?(.success(()))
-                    self.lastMessage = messages.last?.body ?? ""
-                }
             }
         }
     }
     
-    // MARK: - Equatable
-    
-    static func == (lhs: RoomProxy, rhs: RoomProxy) -> Bool {
-        lhs.id == rhs.id
-    }
-    
     // MARK: - Private
     
     fileprivate func appendMessage(_ message: AnyMessage) {
         let message = self.messageFactory.buildRoomMessageFrom(message)
-        lastMessage = message.body
+        messages.append(message)
-        
+        callbacks.send(.updatedMessages)
-        callbacks.send(.addedMessage(message))
     }
 }

ElementX/Sources/Services/Room/RoomProxyProtocol.swift

@@ -17,8 +17,7 @@ enum RoomProxyError: Error {
 }
 
 enum RoomProxyCallback {
-    case addedMessage(RoomMessageProtocol)
+    case updatedMessages
-    case updatedLastMessage
 }
 
 protocol RoomProxyProtocol {
@@ -32,7 +31,7 @@ protocol RoomProxyProtocol {
     var name: String? { get }
     
     var topic: String? { get }
-    var lastMessage: String? { get }
+    var messages: [RoomMessageProtocol] { get }
     
     var avatarURL: String? { get }
     
@@ -42,7 +41,7 @@ protocol RoomProxyProtocol {
     
     func displayNameForUserId(_ userId: String, completion: @escaping (Result<String?, RoomProxyError>) -> Void)
     
-    func paginateBackwards(count: UInt, callback: ((Result<[RoomMessageProtocol], RoomProxyError>) -> Void)?)
+    func paginateBackwards(count: UInt, callback: ((Result<Void, RoomProxyError>) -> Void)?)
     
     var callbacks: PassthroughSubject<RoomProxyCallback, Never> { get }
 }

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):
+            case .updatedMessages:
-                self.messages.append(message)
+                self.callbacks.send(.updatedMessages)
-                self.callbacks.send(.addedMessage)
-            case .updatedLastMessage:
-                break
             }
         }.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):
+            case .success:
-                self.messages.insert(contentsOf: messages.reversed(), at: 0)
+                callback?(.success(()))
-                callback?(.success((self.messages)))
             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)?)
 }