Better timeline handling, based on improved rust APIs.

ElementX/Sources/Screens/HomeScreen/HomeScreenViewModel.swift

@@ -66,8 +66,7 @@ class HomeScreenViewModel: HomeScreenViewModelType, HomeScreenViewModelProtocol
         self.roomList = roomList
         
         roomList.forEach({ roomProxy  in
-            roomProxy.paginateBackwards(start: 0, finish: 1)
-            roomProxy.startLiveEventListener()
+            roomProxy.paginateBackwards(count: 1, callback: nil)
             roomProxy.callbacks.sink { [weak self] callback in
                 switch callback {
                 case .updatedLastMessage:

ElementX/Sources/Screens/RoomScreen/RoomScreenModels.swift

@@ -32,7 +32,6 @@ private var dateFormatter: DateFormatter = {
 }()
 
 struct RoomScreenMessage: Identifiable, Equatable {
-    
     let id: String
     let sender: String
     let text: String
@@ -45,6 +44,5 @@ struct RoomScreenMessage: Identifiable, Equatable {
 
 struct RoomScreenViewState: BindableState {
     var roomTitle: String?
-    var isLoading: Bool = false
     var messages: [RoomScreenMessage] = []
 }

ElementX/Sources/Screens/RoomScreen/RoomScreenViewModel.swift

@@ -50,8 +50,6 @@ class RoomScreenViewModel: RoomScreenViewModelType, RoomScreenViewModelProtocol
                 self.state.messages = self.buildRoomScreenMessages(timelineController.timelineItems)
             }
         }.store(in: &cancellables)
-        
-        timelineController.paginateBackwards(Constants.backPaginationPageSize)
     }
 
     // MARK: - Public

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

@@ -15,33 +15,47 @@
 //
 
 import SwiftUI
+import Introspect
+import Combine
 
 struct RoomScreen: View {
     
-    let timelineBottomDividerIdentifier = "TimelineBottomDividerIdentifier"
+    @State private var scrollViewObserver: ScrollViewObserver = ScrollViewObserver()
+    @State private var messages: [RoomScreenMessage] = []
+    
+    @State private var didRequestBackPagination = false
+    @State private var hasPendingMessages = false
+    @State private var wasBottomVisible = false
+    
+    @State private var previousTopMostMessageIdentifier: String?
+    
+    private let timelineBottomAnchor = "TimelineBottomAnchor"
     
     @ObservedObject var context: RoomScreenViewModel.Context
-    @State var backPaginationMessageIdentifier: String?
     
     var body: some View {
-        ScrollViewReader { reader in
+        ScrollViewReader { scrollViewProxy in
             List {
-                if backPaginationMessageIdentifier != nil {
+                if didRequestBackPagination == false {
+                    Color
+                        .clear
+                        .onAppear {
+                            guard didRequestBackPagination == false else {
+                                return
+                            }
+
+                            didRequestBackPagination = true
+                            context.send(viewAction: .loadPreviousPage)
+                        }
+                } else {
                     HStack {
                         Spacer()
                         ProgressView()
                         Spacer()
                     }
-                } else {
-                    Rectangle()
-                        .onAppear {
-                            let _ = MXLog.debug("Request load previous page")
-                            backPaginationMessageIdentifier = context.viewState.messages.first?.id
-                            context.send(viewAction: .loadPreviousPage)
-                        }
-                        .frame(height: 0.0)
                 }
-                ForEach(context.viewState.messages) { message in
+                
+                ForEach(messages) { message in
                     VStack(alignment: .leading) {
                         HStack {
                             Text(message.sender)
@@ -55,23 +69,117 @@ struct RoomScreen: View {
                     .id(message.id)
                 }
                 
-                Divider()
-                    .id(timelineBottomDividerIdentifier)
+                Color.clear
                     .listRowSeparator(.hidden)
+                    .id(timelineBottomAnchor)
             }
             .listStyle(.plain)
-            .onAppear {
-                reader.scrollTo(timelineBottomDividerIdentifier, anchor: .bottom)
-            }
-            .onChange(of: context.viewState.messages) { _ in
-                if backPaginationMessageIdentifier != nil {
-                    reader.scrollTo(backPaginationMessageIdentifier, anchor: .bottom)
-                    self.backPaginationMessageIdentifier = nil
+            .environment(\.defaultMinListRowHeight, 0.0)
+            .navigationBarTitleDisplayMode(.inline)
+            // Fetch the underlying UIScrollView and start observing it
+            .introspectTableView { scrollView in
+                if scrollView == scrollViewObserver.scrollView {
                     return
                 }
                 
-                reader.scrollTo(timelineBottomDividerIdentifier, anchor: .bottom)
+                scrollViewObserver = ScrollViewObserver(scrollView: scrollView)
             }
+            // Scroll to the bottom when the timeline first appears
+            .onAppear {
+                scrollViewProxy.scrollTo(timelineBottomAnchor, anchor: .bottom)
+            }
+            // When the view state changes check whether the user is interacting with the scroll view.
+            // Updating in that case causes undesired scrolling. Delay until the scroll view stops scrolling.
+            // Also store previous top most message identifier to have something to scroll to after the update.
+            .onChange(of: context.viewState.messages) { newValue in
+                previousTopMostMessageIdentifier = messages.first?.id
+                wasBottomVisible = scrollViewObserver.isBottomVisible
+                
+                if scrollViewObserver.isTracking == true {
+                    hasPendingMessages = true
+                    return
+                }
+                
+                messages = newValue
+            }
+            // Check if we have pending messages to apply and apply them when the scroll finishes scrolling
+            .onReceive(scrollViewObserver.didEndScrolling, perform: {
+                if hasPendingMessages {
+                    messages = context.viewState.messages
+                    hasPendingMessages = false
+                }
+            })
+            // Process timeline updates
+            .onChange(of: messages, perform: { _ in
+                if didRequestBackPagination && wasBottomVisible {
+                    scrollViewProxy.scrollTo(timelineBottomAnchor, anchor: .bottom)
+                } else if didRequestBackPagination == false {
+                    if wasBottomVisible {
+                        scrollViewProxy.scrollTo(timelineBottomAnchor, anchor: .bottom)
+                    }
+                } else {
+                    // Manual scrolling breaks inertia. Don't do it if the scroll view is decelerating
+                    if scrollViewObserver.isDecelerating == false {
+                        scrollViewProxy.scrollTo(previousTopMostMessageIdentifier, anchor: .top)
+                    }
+                }
+                
+                didRequestBackPagination = false
+            })
+        }
+    }
+}
+
+/// Simple wrapper around an UIScrollView that publishes when it finishes scrolling
+class ScrollViewObserver: NSObject, UIScrollViewDelegate {
+    private(set) var scrollView: UIScrollView?
+    
+    let didEndScrolling = PassthroughSubject<Void, Never>()
+    
+    override init() {
+        
+    }
+    
+    init(scrollView: UIScrollView) {
+        self.scrollView = scrollView
+        super.init()
+        
+        scrollView.delegate = self
+    }
+    
+    var isTracking: Bool {
+        self.scrollView?.isTracking == true
+    }
+    
+    var isDecelerating: Bool {
+        self.scrollView?.isDecelerating == true
+    }
+    
+    var isTopVisible: Bool {
+        guard let scrollView = scrollView else {
+            return false
+        }
+
+        return (scrollView.contentOffset.y + scrollView.adjustedContentInset.top) <= 0.0
+    }
+    
+    var isBottomVisible: Bool {
+        guard let scrollView = scrollView else {
+            return false
+        }
+
+        return (scrollView.contentOffset.y) >= (scrollView.contentSize.height - scrollView.frame.size.height)
+    }
+    
+    // MARK: - UIScrollViewDelegate
+    
+    func scrollViewDidEndDecelerating(_ scrollView: UIScrollView) {
+        didEndScrolling.send(())
+    }
+    
+    func scrollViewDidEndDragging(_ scrollView: UIScrollView, willDecelerate decelerating: Bool) {
+        if decelerating == false {
+            didEndScrolling.send(())
         }
     }
 }

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
     }
 }