Set visible ranges on the home screen sliding sync view (#342)

* Set visible ranges on the home screen sliding sync view * Prevent the visible items from being updated while in search mode * Enable diffs on invalidations as they seem to fix duplicated events in the home screen room list * Promoted some diffing logs to info from verbose
2026-11-03 06:55:59 +00:00 · 2022-11-25 17:50:43 +02:00
parent 1781f92882
commit 00cd2ab707
14 changed files with 271 additions and 88 deletions
@@ -89,7 +89,7 @@ class ClientProxy: ClientProxyProtocol {
                                                   RequiredState(key: "m.room.encryption", value: "")])
                    .name(name: "HomeScreenView")
                    .syncMode(mode: .selective)
-                    .addRange(from: 0, to: 50) // FIXME: Replace this with a dynamic solution
+                    .addRange(from: 0, to: 20)
                    .build()

                let slidingSync = try slidingSyncBuilder
@@ -98,8 +98,9 @@ class ClientProxy: ClientProxyProtocol {
                    .coldCache(name: "ElementX")
                    .build()
                
-                self.roomSummaryProvider = RoomSummaryProvider(slidingSyncController: slidingSync,
-                                                               slidingSyncView: slidingSyncView,
+                let slidingSyncViewProxy = SlidingSyncViewProxy(clientProxy: self, slidingSync: slidingSync, slidingSyncView: slidingSyncView)
+                
+                self.roomSummaryProvider = RoomSummaryProvider(slidingSyncViewProxy: slidingSyncViewProxy,
                                                               roomMessageFactory: RoomMessageFactory())
                
                self.slidingSync = slidingSync
@@ -162,6 +163,11 @@ class ClientProxy: ClientProxyProtocol {
        slidingSync?.setObserver(observer: nil)
    }
    
+    func restartSync() {
+        slidingSyncObserverToken?.cancel()
+        slidingSyncObserverToken = slidingSync?.sync()
+    }
+    
    func roomForIdentifier(_ identifier: String) async -> RoomProxyProtocol? {
        let (slidingSyncRoom, room) = await Task.dispatch(on: clientQueue) {
            self.roomTupleForIdentifier(identifier)
@@ -58,7 +58,7 @@ enum PushFormat {
 //    }
 }

-protocol ClientProxyProtocol: MediaProxyProtocol {
+protocol ClientProxyProtocol: AnyObject, MediaProxyProtocol {
    var callbacks: PassthroughSubject<ClientProxyCallback, Never> { get }
    
    var userIdentifier: String { get }
@@ -77,6 +77,8 @@ protocol ClientProxyProtocol: MediaProxyProtocol {
    
    func stopSync()
    
+    func restartSync()
+    
    func roomForIdentifier(_ identifier: String) async -> RoomProxyProtocol?
    
    func loadUserDisplayName() async -> Result<String, ClientProxyError>
@@ -18,7 +18,7 @@ import Combine
 import Foundation
 import MatrixRustSDK

-struct MockClientProxy: ClientProxyProtocol {
+class MockClientProxy: ClientProxyProtocol {
    let callbacks = PassthroughSubject<ClientProxyCallback, Never>()
    
    let userIdentifier: String
@@ -29,10 +29,17 @@ struct MockClientProxy: ClientProxyProtocol {
    
    var roomSummaryProvider: RoomSummaryProviderProtocol? = MockRoomSummaryProvider()
    
+    internal init(userIdentifier: String, roomSummaryProvider: RoomSummaryProviderProtocol? = MockRoomSummaryProvider()) {
+        self.userIdentifier = userIdentifier
+        self.roomSummaryProvider = roomSummaryProvider
+    }
+    
    func startSync() { }
    
    func stopSync() { }
    
+    func restartSync() { }
+    
    func roomForIdentifier(_ identifier: String) async -> RoomProxyProtocol? {
        nil
    }
@@ -0,0 +1,113 @@
+//
+// Copyright 2022 New Vector Ltd
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+import Combine
+import Foundation
+import MatrixRustSDK
+
+private class SlidingSyncViewObserver: SlidingSyncViewRoomListObserver, SlidingSyncViewStateObserver, SlidingSyncViewRoomsCountObserver {
+    /// Publishes room list diffs as they come in through sliding sync
+    let roomListDiffPublisher = PassthroughSubject<SlidingSyncViewRoomsListDiff, Never>()
+    
+    /// Publishes the current state of sliding sync, such as whether its catching up or live.
+    let stateUpdatePublisher = CurrentValueSubject<SlidingSyncState, Never>(.cold)
+    
+    /// Publishes the number of available rooms
+    let countUpdatePublisher = CurrentValueSubject<UInt, Never>(0)
+        
+    // MARK: - SlidingSyncViewRoomListObserver
+    
+    func didReceiveUpdate(diff: SlidingSyncViewRoomsListDiff) {
+        MXLog.verbose("Received room diff")
+        roomListDiffPublisher.send(diff)
+    }
+    
+    // MARK: - SlidingSyncViewStateObserver
+    
+    func didReceiveUpdate(newState: SlidingSyncState) {
+        MXLog.verbose("Updated state: \(newState)")
+        stateUpdatePublisher.send(newState)
+    }
+    
+    // MARK: - SlidingSyncViewRoomsCountObserver
+    
+    func didReceiveUpdate(count: UInt32) {
+        MXLog.verbose("Updated room count: \(count)")
+        countUpdatePublisher.send(UInt(count))
+    }
+}
+
+class SlidingSyncViewProxy {
+    private weak var clientProxy: ClientProxyProtocol?
+    private let slidingSync: SlidingSyncProtocol
+    private let slidingSyncView: SlidingSyncViewProtocol
+    
+    private var listUpdateObserverToken: StoppableSpawn?
+    private var stateUpdateObserverToken: StoppableSpawn?
+    private var countUpdateObserverToken: StoppableSpawn?
+    
+    private var cancellables = Set<AnyCancellable>()
+    
+    let diffPublisher = PassthroughSubject<SlidingSyncViewRoomsListDiff, Never>()
+    let statePublisher = PassthroughSubject<SlidingSyncState, Never>()
+    let countPublisher = PassthroughSubject<UInt, Never>()
+    
+    deinit {
+        listUpdateObserverToken?.cancel()
+        stateUpdateObserverToken?.cancel()
+        countUpdateObserverToken?.cancel()
+    }
+    
+    init(clientProxy: ClientProxyProtocol, slidingSync: SlidingSyncProtocol, slidingSyncView: SlidingSyncViewProtocol) {
+        self.clientProxy = clientProxy
+        self.slidingSync = slidingSync
+        self.slidingSyncView = slidingSyncView
+        
+        let slidingSyncViewObserver = SlidingSyncViewObserver()
+        
+        slidingSyncViewObserver.stateUpdatePublisher
+            .subscribe(statePublisher)
+            .store(in: &cancellables)
+        
+        slidingSyncViewObserver.countUpdatePublisher
+            .subscribe(countPublisher)
+            .store(in: &cancellables)
+        
+        slidingSyncViewObserver.roomListDiffPublisher
+            .subscribe(diffPublisher)
+            .store(in: &cancellables)
+        
+        listUpdateObserverToken = slidingSyncView.observeRoomList(observer: slidingSyncViewObserver)
+        stateUpdateObserverToken = slidingSyncView.observeState(observer: slidingSyncViewObserver)
+        countUpdateObserverToken = slidingSyncView.observeRoomsCount(observer: slidingSyncViewObserver)
+    }
+    
+    func currentRoomsList() -> [RoomListEntry] {
+        slidingSyncView.currentRoomsList()
+    }
+    
+    func roomForIdentifier(_ identifier: String) throws -> SlidingSyncRoomProtocol? {
+        try slidingSync.getRoom(roomId: identifier)
+    }
+    
+    func updateVisibleRange(_ range: ClosedRange<Int>) {
+        MXLog.info("Setting sliding sync view range to \(range)")
+        
+        slidingSyncView.setRange(start: UInt32(range.lowerBound), end: UInt32(range.upperBound))
+        
+        clientProxy?.restartSync()
+    }
+}