No restart sliding sync (#866)

* Adopt new sliding sync list interaction APIs

* Re-enable summary providers, be more leninent in the list proxy and remove now unnecessary restartSync method

* Rename all sliding sync views to lists

* Bump the SDK to v1.0.61-alpha

ElementX.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved

@@ -111,8 +111,8 @@
       "kind" : "remoteSourceControl",
       "location" : "https://github.com/matrix-org/matrix-rust-components-swift",
       "state" : {
-        "revision" : "6c11b548074f4bfedfe73a9724d7d8d1709b0ede",
+        "revision" : "1c1cd29d5720ecd0f6043b5d8f5a40d30dd5ec41",
-        "version" : "1.0.60-alpha"
+        "version" : "1.0.61-alpha"
       }
     },
     {
@@ -181,7 +181,7 @@
     {
       "identity" : "swift-snapshot-testing",
       "kind" : "remoteSourceControl",
-      "location" : "https://github.com/pointfreeco/swift-snapshot-testing",
+      "location" : "https://github.com/pointfreeco/swift-snapshot-testing.git",
       "state" : {
         "revision" : "cef5b3f6f11781dd4591bdd1dd0a3d22bd609334",
         "version" : "1.11.0"

ElementX/Sources/Services/Client/ClientProxy.swift

@@ -60,19 +60,19 @@ class ClientProxy: ClientProxyProtocol {
     private var slidingSyncObserverToken: TaskHandle?
     private var slidingSync: SlidingSyncProtocol?
     
-    var visibleRoomsSlidingSyncView: SlidingSyncList?
+    var visibleRoomsListBuilder: SlidingSyncListBuilder?
-    var visibleRoomsViewProxy: SlidingSyncViewProxy?
+    var visibleRoomsListProxy: SlidingSyncListProxy?
     var visibleRoomsSummaryProvider: RoomSummaryProviderProtocol?
     
-    var allRoomsSlidingSyncView: SlidingSyncList?
+    var allRoomsListBuilder: SlidingSyncListBuilder?
-    var allRoomsViewProxy: SlidingSyncViewProxy?
+    var allRoomsListProxy: SlidingSyncListProxy?
     var allRoomsSummaryProvider: RoomSummaryProviderProtocol?
 
-    var invitesSlidingSyncView: SlidingSyncList?
+    var invitesListBuilder: SlidingSyncListBuilder?
-    var invitesViewProxy: SlidingSyncViewProxy?
+    var invitesListProxy: SlidingSyncListProxy?
     var invitesSummaryProvider: RoomSummaryProviderProtocol?
 
-    var notificationsSlidingSyncView: SlidingSyncList?
+    var notificationsListBuilder: SlidingSyncListBuilder?
 
     private var loadCachedAvatarURLTask: Task<Void, Never>?
     private let avatarURLSubject = CurrentValueSubject<URL?, Never>(nil)
@@ -84,7 +84,7 @@ class ClientProxy: ClientProxyProtocol {
     }
     
     private var cancellables = Set<AnyCancellable>()
-    private var visibleRoomsViewProxyStateObservationToken: AnyCancellable?
+    private var visibleRoomsListProxyStateObservationToken: AnyCancellable?
     
     deinit {
         // These need to be inlined instead of using stopSync()
@@ -304,12 +304,6 @@ class ClientProxy: ClientProxyProtocol {
         }
     }
         
-    private func restartSync() {
-        MXLog.info("Restarting sync")
-        stopSync()
-        startSync()
-    }
-    
     private func configureSlidingSync() {
         guard slidingSync == nil else {
             fatalError("This shouldn't be called more than once")
@@ -320,34 +314,34 @@ class ClientProxy: ClientProxyProtocol {
             
             // List observers need to be setup before calling build() on the SlidingSyncBuilder otherwise
             // cold cache state and count updates will be lost
-            buildAndConfigureVisibleRoomsSlidingSyncView()
+            buildAndConfigureVisibleRoomsSlidingSyncList()
-            buildAndConfigureAllRoomsSlidingSyncView()
+            buildAndConfigureAllRoomsSlidingSyncList()
-            buildAndConfigureInvitesSlidingSyncView()
+            buildAndConfigureInvitesSlidingSyncList()
-            buildAndConfigureNotificationSyncView()
+            buildAndConfigureNotificationsSlidingSyncList()
             
-            guard let visibleRoomsSlidingSyncView else {
+            guard let visibleRoomsListBuilder else {
                 MXLog.error("Visible rooms sliding sync view unavailable")
                 return
             }
             
             let roomListRecencyOrderingAllowedEventTypes = ["m.room.message", "m.room.encrypted", "m.sticker"]
             
-            // Add the visibleRoomsSlidingSyncView here so that it can take advantage of the SS builder cold cache
+            // Add the visibleRoomsSlidingSyncList here so that it can take advantage of the SS builder cold cache
-            // We will still register the allRoomsSlidingSyncView later, and than will have no cache
+            // We will still register the allRoomsSlidingSyncList later, and than will have no cache
             let slidingSync = try slidingSyncBuilder
-                .addList(v: visibleRoomsSlidingSyncView)
+                .addList(listBuilder: visibleRoomsListBuilder)
                 .withCommonExtensions()
                 .bumpEventTypes(bumpEventTypes: roomListRecencyOrderingAllowedEventTypes)
                 .storageKey(name: "ElementX")
                 .build()
             
             // Don't forget to update the view proxies after building the slidingSync
-            visibleRoomsViewProxy?.setSlidingSync(slidingSync: slidingSync)
+            visibleRoomsListProxy?.setSlidingSync(slidingSync: slidingSync)
-            allRoomsViewProxy?.setSlidingSync(slidingSync: slidingSync)
+            allRoomsListProxy?.setSlidingSync(slidingSync: slidingSync)
-            invitesViewProxy?.setSlidingSync(slidingSync: slidingSync)
+            invitesListProxy?.setSlidingSync(slidingSync: slidingSync)
             
             // Build the room summary providers later so the sliding sync view proxies are up to date and the
-            // currentRoomList is populate with the data from the cold cache
+            // currentRoomList is populated with the data from the cold cache
             buildRoomSummaryProviders()
             
             slidingSync.setObserver(observer: WeakClientProxyWrapper(clientProxy: self))
@@ -358,90 +352,93 @@ class ClientProxy: ClientProxyProtocol {
         }
     }
     
-    private func buildAndConfigureVisibleRoomsSlidingSyncView() {
+    private func buildAndConfigureVisibleRoomsSlidingSyncList() {
-        guard visibleRoomsSlidingSyncView == nil else {
+        guard visibleRoomsListBuilder == nil else {
             fatalError("This shouldn't be called more than once")
         }
         
-        let visibleRoomsSlidingSyncView = SlidingSyncListBuilder(name: "CurrentlyVisibleRooms")
+        let listName = "CurrentlyVisibleRooms"
+        
+        let visibleRoomsListProxy = SlidingSyncListProxy(name: listName)
+        
+        let visibleRoomsListBuilder = SlidingSyncListBuilder(name: listName)
             .timelineLimit(limit: UInt32(SlidingSyncConstants.initialTimelineLimit)) // Starts off with zero to quickly load rooms, then goes to 1 while scrolling to quickly load last messages and 20 when the scrolling stops to load room history
             .requiredState(requiredState: slidingSyncRequiredState)
             .filters(filters: slidingSyncFilters)
             .syncMode(mode: .selective)
             .addRange(from: 0, to: 20)
-            .build()
+            .onceBuilt(callback: visibleRoomsListProxy)
 
-        let visibleRoomsViewProxy = SlidingSyncViewProxy(slidingSyncView: visibleRoomsSlidingSyncView, name: "Visible rooms")
+        self.visibleRoomsListBuilder = visibleRoomsListBuilder
+        self.visibleRoomsListProxy = visibleRoomsListProxy
 
-        self.visibleRoomsSlidingSyncView = visibleRoomsSlidingSyncView
+        // The allRoomsSlidingSyncList will be registered as soon as the visibleRoomsSlidingSyncList receives its first update
-        self.visibleRoomsViewProxy = visibleRoomsViewProxy
+        visibleRoomsListProxyStateObservationToken = visibleRoomsListProxy.statePublisher.sink { [weak self] state in
-
-        // Changes to the visibleRoomsSlidingSyncView range need to restart the connection to be applied
-        visibleRoomsViewProxy.visibleRangeUpdatePublisher.sink { [weak self] in
-            self?.restartSync()
-        }
-        .store(in: &cancellables)
-
-        // The allRoomsSlidingSyncView will be registered as soon as the visibleRoomsSlidingSyncView receives its first update
-        visibleRoomsViewProxyStateObservationToken = visibleRoomsViewProxy.statePublisher.sink { [weak self] state in
             guard state == .fullyLoaded else {
                 return
             }
             
             MXLog.info("Visible rooms view received first update, configuring views post initial sync")
             self?.configureViewsPostInitialSync()
-            self?.visibleRoomsViewProxyStateObservationToken = nil
+            self?.visibleRoomsListProxyStateObservationToken = nil
         }
     }
     
-    private func buildAndConfigureAllRoomsSlidingSyncView() {
+    private func buildAndConfigureAllRoomsSlidingSyncList() {
-        guard allRoomsSlidingSyncView == nil else {
+        guard allRoomsListBuilder == nil else {
             fatalError("This shouldn't be called more than once")
         }
         
-        let allRoomsSlidingSyncView = SlidingSyncListBuilder(name: "AllRooms")
+        let listName = "AllRooms"
+        
+        let allRoomsListProxy = SlidingSyncListProxy(name: listName)
+
+        let allRoomsListBuilder = SlidingSyncListBuilder(name: listName)
             .noTimelineLimit()
             .requiredState(requiredState: slidingSyncRequiredState)
             .filters(filters: slidingSyncFilters)
             .syncMode(mode: .growing)
             .batchSize(batchSize: 100)
-            .build()
+            .onceBuilt(callback: allRoomsListProxy)
 
-        self.allRoomsSlidingSyncView = allRoomsSlidingSyncView
+        self.allRoomsListBuilder = allRoomsListBuilder
-        allRoomsViewProxy = SlidingSyncViewProxy(slidingSyncView: allRoomsSlidingSyncView, name: "All rooms")
+        self.allRoomsListProxy = allRoomsListProxy
     }
 
-    private func buildAndConfigureInvitesSlidingSyncView() {
+    private func buildAndConfigureInvitesSlidingSyncList() {
-        guard invitesSlidingSyncView == nil else {
+        guard invitesListBuilder == nil else {
             fatalError("This shouldn't be called more than once")
         }
         
-        let invitesView = SlidingSyncListBuilder(name: "Invites")
+        let listName = "Invites"
+        
+        let invitesListProxy = SlidingSyncListProxy(name: "Invites")
+
+        let invitesListBuilder = SlidingSyncListBuilder(name: listName)
             .noTimelineLimit()
             .requiredState(requiredState: slidingSyncInvitesRequiredState)
             .filters(filters: slidingSyncInviteFilters)
             .syncMode(mode: .growing)
             .batchSize(batchSize: 100)
-            .build()
+            .onceBuilt(callback: invitesListProxy)
 
-        invitesSlidingSyncView = invitesView
+        self.invitesListBuilder = invitesListBuilder
-        invitesViewProxy = SlidingSyncViewProxy(slidingSyncView: invitesView, name: "Invites")
+        self.invitesListProxy = invitesListProxy
     }
 
-    private func buildAndConfigureNotificationSyncView() {
+    private func buildAndConfigureNotificationsSlidingSyncList() {
-        guard notificationsSlidingSyncView == nil else {
+        guard notificationsListBuilder == nil else {
             fatalError("This shouldn't be called more than once")
         }
         
-        let notificationsSlidingSyncView = SlidingSyncListBuilder(name: "Notifications")
+        let notificationsListBuilder = SlidingSyncListBuilder(name: "Notifications")
             .noTimelineLimit()
             .requiredState(requiredState: slidingSyncNotificationsRequiredState)
             .filters(filters: slidingSyncNotificationsFilters)
             .syncMode(mode: .growing)
             .batchSize(batchSize: 100)
-            .build()
         
-        self.notificationsSlidingSyncView = notificationsSlidingSyncView
+        self.notificationsListBuilder = notificationsListBuilder
     }
 
     private func buildRoomSummaryProviders() {
@@ -449,18 +446,18 @@ class ClientProxy: ClientProxyProtocol {
             fatalError("This shouldn't be called more than once")
         }
         
-        guard let visibleRoomsViewProxy, let allRoomsViewProxy, let invitesViewProxy else {
+        guard let visibleRoomsListProxy, let allRoomsListProxy, let invitesListProxy else {
             MXLog.error("Sliding sync view proxies unavailable")
             return
         }
         
-        visibleRoomsSummaryProvider = RoomSummaryProvider(slidingSyncViewProxy: visibleRoomsViewProxy,
+        visibleRoomsSummaryProvider = RoomSummaryProvider(slidingSyncListProxy: visibleRoomsListProxy,
                                                           eventStringBuilder: RoomEventStringBuilder(stateEventStringBuilder: RoomStateEventStringBuilder(userID: userID)))
         
-        allRoomsSummaryProvider = RoomSummaryProvider(slidingSyncViewProxy: allRoomsViewProxy,
+        allRoomsSummaryProvider = RoomSummaryProvider(slidingSyncListProxy: allRoomsListProxy,
                                                       eventStringBuilder: RoomEventStringBuilder(stateEventStringBuilder: RoomStateEventStringBuilder(userID: userID)))
         
-        invitesSummaryProvider = RoomSummaryProvider(slidingSyncViewProxy: invitesViewProxy,
+        invitesSummaryProvider = RoomSummaryProvider(slidingSyncListProxy: invitesListProxy,
                                                      eventStringBuilder: RoomEventStringBuilder(stateEventStringBuilder: RoomStateEventStringBuilder(userID: userID)))
     }
     
@@ -510,35 +507,33 @@ class ClientProxy: ClientProxyProtocol {
                                                                               notTags: [])
     
     private func configureViewsPostInitialSync() {
-        if let visibleRoomsSlidingSyncView {
+        if let visibleRoomsListProxy {
             MXLog.info("Setting visible rooms view timeline limit to \(SlidingSyncConstants.lastMessageTimelineLimit)")
-            visibleRoomsSlidingSyncView.setTimelineLimit(value: UInt32(SlidingSyncConstants.lastMessageTimelineLimit))
+            visibleRoomsListProxy.updateVisibleRange(nil, timelineLimit: SlidingSyncConstants.lastMessageTimelineLimit)
         } else {
             MXLog.error("Visible rooms sliding sync view unavailable")
         }
 
-        if let allRoomsSlidingSyncView {
+        if let allRoomsListBuilder {
             MXLog.info("Registering all rooms view")
-            _ = slidingSync?.addList(list: allRoomsSlidingSyncView)
+            _ = slidingSync?.addList(listBuilder: allRoomsListBuilder)
         } else {
             MXLog.error("All rooms sliding sync view unavailable")
         }
 
-        if let invitesSlidingSyncView {
+        if let invitesListBuilder {
             MXLog.info("Registering invites view")
-            _ = slidingSync?.addList(list: invitesSlidingSyncView)
+            _ = slidingSync?.addList(listBuilder: invitesListBuilder)
         } else {
             MXLog.error("Invites sliding sync view unavailable")
         }
 
-        if let notificationsSlidingSyncView {
+        if let notificationsListBuilder {
             MXLog.info("Registering notifications view")
-            _ = slidingSync?.addList(list: notificationsSlidingSyncView)
+            _ = slidingSync?.addList(listBuilder: notificationsListBuilder)
         } else {
             MXLog.error("Notifications sliding sync view unavailable")
         }
-        
-        restartSync()
     }
     
     private func roomTupleForIdentifier(_ identifier: String) -> (SlidingSyncRoom?, Room?) {

ElementX/Sources/Services/Client/SlidingSyncListProxy.swift

@@ -18,7 +18,7 @@ import Combine
 import Foundation
 import MatrixRustSDK
 
-private class SlidingSyncViewObserver: SlidingSyncListRoomListObserver, SlidingSyncListStateObserver, SlidingSyncListRoomsCountObserver {
+private class SlidingSyncListObserver: SlidingSyncListRoomListObserver, SlidingSyncListStateObserver, SlidingSyncListRoomsCountObserver {
     /// Publishes room list diffs as they come in through sliding sync
     let roomListDiffPublisher = PassthroughSubject<SlidingSyncListRoomsListDiff, Never>()
     
@@ -56,9 +56,10 @@ private class SlidingSyncViewObserver: SlidingSyncListRoomListObserver, SlidingS
     }
 }
 
-class SlidingSyncViewProxy {
+class SlidingSyncListProxy: SlidingSyncListOnceBuilt {
-    private var slidingSync: SlidingSyncProtocol!
+    private let name: String
-    private let slidingSyncView: SlidingSyncListProtocol
+    private var slidingSync: SlidingSyncProtocol?
+    private var slidingSyncList: SlidingSyncListProtocol?
     
     private var listUpdateObserverToken: TaskHandle?
     private var stateUpdateObserverToken: TaskHandle?
@@ -69,7 +70,6 @@ class SlidingSyncViewProxy {
     let diffPublisher = PassthroughSubject<SlidingSyncListRoomsListDiff, Never>()
     let statePublisher = PassthroughSubject<SlidingSyncState, Never>()
     let countPublisher = PassthroughSubject<UInt, Never>()
-    let visibleRangeUpdatePublisher = PassthroughSubject<Void, Never>()
     
     deinit {
         listUpdateObserverToken?.cancel()
@@ -77,26 +77,8 @@ class SlidingSyncViewProxy {
         countUpdateObserverToken?.cancel()
     }
     
-    init(slidingSyncView: SlidingSyncListProtocol, name: String) {
+    init(name: String) {
-        self.slidingSyncView = slidingSyncView
+        self.name = name
-        
-        let slidingSyncViewObserver = SlidingSyncViewObserver(name: name)
-        
-        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 setSlidingSync(slidingSync: SlidingSyncProtocol) {
@@ -104,23 +86,60 @@ class SlidingSyncViewProxy {
     }
     
     func currentRoomsList() -> [RoomListEntry] {
-        slidingSyncView.currentRoomList()
+        guard let slidingSyncList else {
+            return []
+        }
+        
+        return slidingSyncList.currentRoomList()
     }
     
     func roomForIdentifier(_ identifier: String) throws -> SlidingSyncRoomProtocol? {
-        try slidingSync.getRoom(roomId: identifier)
+        guard let slidingSync else {
+            return nil
+        }
+        
+        return try slidingSync.getRoom(roomId: identifier)
     }
     
-    func updateVisibleRange(_ range: Range<Int>, timelineLimit: UInt) {
+    func updateVisibleRange(_ range: Range<Int>?, timelineLimit: UInt?) {
-        MXLog.info("Setting sliding sync view range to \(range), timeline limit: \(timelineLimit)")
-        
         do {
-            try slidingSyncView.setRange(start: UInt32(range.lowerBound), end: UInt32(range.upperBound))
+            if let range {
-            slidingSyncView.setTimelineLimit(value: UInt32(timelineLimit))
+                MXLog.info("Setting '\(name)' list range to \(range)")
+                try slidingSyncList?.setRange(start: UInt32(range.lowerBound), end: UInt32(range.upperBound))
+            }
             
-            visibleRangeUpdatePublisher.send(())
+            if let timelineLimit {
+                MXLog.info("Setting '\(name)' list timeline limit to \(timelineLimit)")
+                slidingSyncList?.setTimelineLimit(value: UInt32(timelineLimit))
+            }
         } catch {
             MXLog.error("Failed setting sliding sync list range with error: \(error)")
         }
     }
+    
+    // MARK: - SlidingSyncListOnceBuilt
+    
+    func updateList(list: MatrixRustSDK.SlidingSyncList) -> MatrixRustSDK.SlidingSyncList {
+        slidingSyncList = list
+        
+        let slidingSyncListObserver = SlidingSyncListObserver(name: name)
+        
+        slidingSyncListObserver.stateUpdatePublisher
+            .subscribe(statePublisher)
+            .store(in: &cancellables)
+        
+        slidingSyncListObserver.countUpdatePublisher
+            .subscribe(countPublisher)
+            .store(in: &cancellables)
+        
+        slidingSyncListObserver.roomListDiffPublisher
+            .subscribe(diffPublisher)
+            .store(in: &cancellables)
+        
+        listUpdateObserverToken = list.observeRoomList(observer: slidingSyncListObserver)
+        stateUpdateObserverToken = list.observeState(observer: slidingSyncListObserver)
+        countUpdateObserverToken = list.observeRoomsCount(observer: slidingSyncListObserver)
+        
+        return list
+    }
 }

ElementX/Sources/Services/Room/RoomSummary/RoomSummaryProvider.swift

@@ -19,7 +19,7 @@ import Foundation
 import MatrixRustSDK
 
 class RoomSummaryProvider: RoomSummaryProviderProtocol {
-    private let slidingSyncViewProxy: SlidingSyncViewProxy
+    private let slidingSyncListProxy: SlidingSyncListProxy
     private let serialDispatchQueue: DispatchQueue
     private let eventStringBuilder: RoomEventStringBuilder
     
@@ -47,34 +47,34 @@ class RoomSummaryProvider: RoomSummaryProviderProtocol {
         }
     }
     
-    init(slidingSyncViewProxy: SlidingSyncViewProxy, eventStringBuilder: RoomEventStringBuilder) {
+    init(slidingSyncListProxy: SlidingSyncListProxy, eventStringBuilder: RoomEventStringBuilder) {
-        self.slidingSyncViewProxy = slidingSyncViewProxy
+        self.slidingSyncListProxy = slidingSyncListProxy
         serialDispatchQueue = DispatchQueue(label: "io.element.elementx.roomsummaryprovider", qos: .utility)
         self.eventStringBuilder = eventStringBuilder
         
-        rooms = slidingSyncViewProxy.currentRoomsList().map { roomListEntry in
+        rooms = slidingSyncListProxy.currentRoomsList().map { roomListEntry in
             buildSummaryForRoomListEntry(roomListEntry)
         }
         
         roomListSubject.send(rooms) // didSet not called from initialisers
         
-        slidingSyncViewProxy.statePublisher
+        slidingSyncListProxy.statePublisher
             .map(RoomSummaryProviderState.init)
             .subscribe(stateSubject)
             .store(in: &cancellables)
         
-        slidingSyncViewProxy.countPublisher
+        slidingSyncListProxy.countPublisher
             .subscribe(countSubject)
             .store(in: &cancellables)
         
-        slidingSyncViewProxy.diffPublisher
+        slidingSyncListProxy.diffPublisher
             .collect(.byTime(serialDispatchQueue, 0.025))
             .sink { [weak self] in self?.updateRoomsWithDiffs($0) }
             .store(in: &cancellables)
     }
     
     func updateVisibleRange(_ range: Range<Int>, timelineLimit: UInt) {
-        slidingSyncViewProxy.updateVisibleRange(range, timelineLimit: timelineLimit)
+        slidingSyncListProxy.updateVisibleRange(range, timelineLimit: timelineLimit)
     }
     
     // MARK: - Private
@@ -111,7 +111,7 @@ class RoomSummaryProvider: RoomSummaryProviderProtocol {
     }
         
     private func buildRoomSummaryForIdentifier(_ identifier: String, invalidated: Bool) -> RoomSummary {
-        guard let room = try? slidingSyncViewProxy.roomForIdentifier(identifier) else {
+        guard let room = try? slidingSyncListProxy.roomForIdentifier(identifier) else {
             MXLog.error("Failed finding room with id: \(identifier)")
             return .empty
         }

project.yml

@@ -42,7 +42,7 @@ include:
 packages:
   MatrixRustSDK:
     url: https://github.com/matrix-org/matrix-rust-components-swift
-    exactVersion: 1.0.60-alpha
+    exactVersion: 1.0.61-alpha
     # path: ../matrix-rust-sdk
   DesignKit:
     path: DesignKit