Use the SDK's offline detection everywhere (except for restarting the sync loop). (#4472)

* Use the SDK's offline state to drive the offline indicator.

* Only use network reachability for restarting the sync loop, use the homeserver reachability for requests.

* Add a separate indicator to distinguish when the server is unreachable but the device is online.

ElementX/Sources/Services/Client/ClientProxy.swift

@@ -137,6 +137,11 @@ class ClientProxy: ClientProxyProtocol {
         verificationStateSubject.asCurrentValuePublisher()
     }
     
+    private let homeserverReachabilitySubject = CurrentValueSubject<NetworkMonitorReachability, Never>(.reachable)
+    var homeserverReachabilityPublisher: CurrentValuePublisher<NetworkMonitorReachability, Never> {
+        homeserverReachabilitySubject.asCurrentValuePublisher()
+    }
+    
     private let timelineMediaVisibilitySubject = CurrentValueSubject<TimelineMediaVisibility, Never>(.always)
     var timelineMediaVisibilityPublisher: CurrentValuePublisher<TimelineMediaVisibility, Never> {
         timelineMediaVisibilitySubject.asCurrentValuePublisher()
@@ -218,10 +223,10 @@ class ClientProxy: ClientProxyProtocol {
         })
         
         sendQueueStatusSubject
-            .combineLatest(networkMonitor.reachabilityPublisher)
+            .combineLatest(homeserverReachabilityPublisher)
             .debounce(for: 1.0, scheduler: DispatchQueue.main)
             .sink { enabled, reachability in
-                MXLog.info("Send queue status changed to enabled: \(enabled), reachability: \(reachability)")
+                MXLog.info("Send queue status changed to enabled: \(enabled), homeserver reachability: \(reachability)")
                 
                 if enabled == false, reachability == .reachable {
                     MXLog.info("Enabling all send queues")
@@ -926,12 +931,11 @@ class ClientProxy: ClientProxyProtocol {
             
             switch state {
             case .running, .terminated, .idle:
-                break
+                homeserverReachabilitySubject.send(.reachable)
+            case .offline:
+                homeserverReachabilitySubject.send(.unreachable)
             case .error:
                 restartSync()
-            case .offline:
-                // This needs to be enabled in the client builder first to be actually used
-                break
             }
         })
     }
@@ -1196,6 +1200,7 @@ private struct ClientProxyServices {
         let syncService = try await client
             .syncService()
             .withCrossProcessLock()
+            .withOfflineMode()
             .withSharePos(enable: true)
             .finish()
         

ElementX/Sources/Services/Client/ClientProxyProtocol.swift

@@ -80,6 +80,8 @@ protocol ClientProxyProtocol: AnyObject, MediaLoaderProtocol {
     
     var verificationStatePublisher: CurrentValuePublisher<SessionVerificationState, Never> { get }
     
+    var homeserverReachabilityPublisher: CurrentValuePublisher<NetworkMonitorReachability, Never> { get }
+    
     var userID: String { get }
 
     var deviceID: String? { get }

ElementX/Sources/Services/Media/Provider/MediaProvider.swift

@@ -12,14 +12,14 @@ import UIKit
 class MediaProvider: MediaProviderProtocol {
     private let mediaLoader: MediaLoaderProtocol
     private let imageCache: Kingfisher.ImageCache
-    private let networkMonitor: NetworkMonitorProtocol?
+    private let homeserverReachabilityPublisher: CurrentValuePublisher<NetworkMonitorReachability, Never>?
     
     init(mediaLoader: MediaLoaderProtocol,
          imageCache: Kingfisher.ImageCache,
-         networkMonitor: NetworkMonitorProtocol?) {
+         homeserverReachabilityPublisher: CurrentValuePublisher<NetworkMonitorReachability, Never>?) {
         self.mediaLoader = mediaLoader
         self.imageCache = imageCache
-        self.networkMonitor = networkMonitor
+        self.homeserverReachabilityPublisher = homeserverReachabilityPublisher
     }
     
     // MARK: Images
@@ -67,8 +67,8 @@ class MediaProvider: MediaProviderProtocol {
     }
     
     func loadImageRetryingOnReconnection(_ source: MediaSourceProxy, size: CGSize?) -> Task<UIImage, any Error> {
-        guard let networkMonitor else {
-            fatalError("This method shouldn't be invoked without a NetworkMonitor set.")
+        guard let homeserverReachabilityPublisher else {
+            fatalError("This method shouldn't be invoked without a homeserver reachability publisher set.")
         }
         
         return Task {
@@ -80,7 +80,7 @@ class MediaProvider: MediaProviderProtocol {
                 throw MediaProviderError.cancelled
             }
             
-            for await reachability in networkMonitor.reachabilityPublisher.values {
+            for await reachability in homeserverReachabilityPublisher.values {
                 guard !Task.isCancelled else {
                     throw MediaProviderError.cancelled
                 }

ElementX/Sources/Services/UserSession/UserSessionStore.swift

@@ -96,7 +96,7 @@ class UserSessionStore: UserSessionStoreProtocol {
     private func buildUserSessionWithClient(_ clientProxy: ClientProxyProtocol) -> UserSessionProtocol {
         let mediaProvider = MediaProvider(mediaLoader: clientProxy,
                                           imageCache: .onlyInMemory,
-                                          networkMonitor: networkMonitor)
+                                          homeserverReachabilityPublisher: clientProxy.homeserverReachabilityPublisher)
         
         let voiceMessageMediaManager = VoiceMessageMediaManager(mediaProvider: mediaProvider)