Delay setting up subscriptions until the RoomListService is running in order to avoid cancelling in flight initial sync requests

ElementX/Sources/Services/Client/ClientProxy.swift

@@ -92,6 +92,8 @@ class ClientProxy: ClientProxyProtocol {
             .asCurrentValuePublisher()
     }
     
+    private let roomListServiceStateSubject = CurrentValueSubject<RoomListServiceState, Never>(.initial)
+    
     private var cancellables = Set<AnyCancellable>()
     
     /// Will be `true` whilst the app cleans up and forces a logout. Prevents the sync service from restarting
@@ -759,6 +761,7 @@ class ClientProxy: ClientProxyProtocol {
                                                             shouldPrefixSenderName: true)
             
             roomSummaryProvider = RoomSummaryProvider(roomListService: roomListService,
+                                                      roomListServiceStatePublisher: roomListServiceStateSubject.asCurrentValuePublisher(),
                                                       eventStringBuilder: eventStringBuilder,
                                                       name: "AllRooms",
                                                       shouldUpdateVisibleRange: true,
@@ -767,6 +770,7 @@ class ClientProxy: ClientProxyProtocol {
             try await roomSummaryProvider?.setRoomList(roomListService.allRooms())
             
             alternateRoomSummaryProvider = RoomSummaryProvider(roomListService: roomListService,
+                                                               roomListServiceStatePublisher: roomListServiceStateSubject.asCurrentValuePublisher(),
                                                                eventStringBuilder: eventStringBuilder,
                                                                name: "MessageForwarding",
                                                                notificationSettings: notificationSettings,
@@ -802,9 +806,13 @@ class ClientProxy: ClientProxyProtocol {
 
     private func createRoomListServiceObserver(_ roomListService: RoomListService) -> TaskHandle {
         roomListService.state(listener: RoomListStateListenerProxy { [weak self] state in
+            guard let self else { return }
+            
             MXLog.info("Received room list update: \(state)")
-            guard let self,
-                  state != .error,
+            
+            roomListServiceStateSubject.send(state)
+            
+            guard state != .error,
                   state != .terminated else {
                 // The sync service is responsible of handling error and termination
                 return

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

@@ -20,6 +20,7 @@ import MatrixRustSDK
 
 class RoomSummaryProvider: RoomSummaryProviderProtocol {
     private let roomListService: RoomListServiceProtocol
+    private let roomListServiceStatePublisher: CurrentValuePublisher<RoomListServiceState, Never>
     private let eventStringBuilder: RoomEventStringBuilder
     private let name: String
     private let shouldUpdateVisibleRange: Bool
@@ -36,6 +37,7 @@ class RoomSummaryProvider: RoomSummaryProviderProtocol {
     private var roomList: RoomListProtocol?
     
     private var cancellables = Set<AnyCancellable>()
+    private var roomListServiceStateCancellable: AnyCancellable?
     private var listUpdatesSubscriptionResult: RoomListEntriesWithDynamicAdaptersResult?
     private var stateUpdatesTaskHandle: TaskHandle?
     
@@ -64,12 +66,14 @@ class RoomSummaryProvider: RoomSummaryProviderProtocol {
     ///   to the room list service through the `applyInput(input: .viewport(ranges` api. Only useful for
     ///   lists that need to update the visible range on Sliding Sync
     init(roomListService: RoomListServiceProtocol,
+         roomListServiceStatePublisher: CurrentValuePublisher<RoomListServiceState, Never>,
          eventStringBuilder: RoomEventStringBuilder,
          name: String,
          shouldUpdateVisibleRange: Bool = false,
          notificationSettings: NotificationSettingsProxyProtocol,
          appSettings: AppSettings) {
         self.roomListService = roomListService
+        self.roomListServiceStatePublisher = roomListServiceStatePublisher
         serialDispatchQueue = DispatchQueue(label: "io.element.elementx.roomsummaryprovider", qos: .default)
         self.eventStringBuilder = eventStringBuilder
         self.name = name
@@ -82,7 +86,16 @@ class RoomSummaryProvider: RoomSummaryProviderProtocol {
             .sink { [weak self] in self?.updateRoomsWithDiffs($0) }
             .store(in: &cancellables)
         
-        setupVisibleRangeObservers()
+        roomListServiceStateCancellable = roomListServiceStatePublisher
+            .receive(on: DispatchQueue.main)
+            .sink { [weak self] state in
+                guard let self else { return }
+                
+                if state == .running {
+                    setupVisibleRangeObservers()
+                    roomListServiceStateCancellable = nil
+                }
+            }
         
         setupNotificationSettingsSubscription()
     }