Switch to a custom HomeserverReachability instead of different publishers

ElementX/Sources/Services/Client/ClientProxy.swift

@@ -180,21 +180,11 @@ class ClientProxy: ClientProxyProtocol {
         verificationStateSubject.asCurrentValuePublisher()
     }
     
-    /// Reports unreachable while suspended (the store is closed) as well as when offline. Use this to gate
-    /// work that needs an open store, such as media loading.
-    private let homeserverReachabilitySubject = CurrentValueSubject<NetworkMonitorReachability, Never>(.reachable)
-    var homeserverReachabilityPublisher: CurrentValuePublisher<NetworkMonitorReachability, Never> {
+    private let homeserverReachabilitySubject = CurrentValueSubject<HomeserverReachability, Never>(.reachable)
+    var homeserverReachabilityPublisher: CurrentValuePublisher<HomeserverReachability, Never> {
         homeserverReachabilitySubject.asCurrentValuePublisher()
     }
     
-    /// The homeserver's reachability derived from the sync service alone, i.e. it stays reachable while the
-    /// client is suspended. Use this for user-facing messaging so we don't claim the server is unreachable
-    /// when we've simply paused syncing.
-    private let homeserverConnectivitySubject = CurrentValueSubject<NetworkMonitorReachability, Never>(.reachable)
-    var homeserverConnectivityPublisher: CurrentValuePublisher<NetworkMonitorReachability, Never> {
-        homeserverConnectivitySubject.asCurrentValuePublisher()
-    }
-    
     private let timelineMediaVisibilitySubject = CurrentValueSubject<TimelineMediaVisibility, Never>(.always)
     var timelineMediaVisibilityPublisher: CurrentValuePublisher<TimelineMediaVisibility, Never> {
         timelineMediaVisibilitySubject.asCurrentValuePublisher()
@@ -1210,12 +1200,12 @@ class ClientProxy: ClientProxyProtocol {
     }
     
     private func updateHomeserverReachability() {
-        homeserverConnectivitySubject.send(syncServiceState == .offline ? .unreachable : .reachable)
-        
-        let reachability: NetworkMonitorReachability = if desiredServiceState == .running, syncServiceState != .offline {
-            .reachable
-        } else {
+        let reachability: HomeserverReachability = if desiredServiceState != .running {
+            .suspended
+        } else if syncServiceState == .offline {
             .unreachable
+        } else {
+            .reachable
         }
         
         homeserverReachabilitySubject.send(reachability)

ElementX/Sources/Services/Client/ClientProxyProtocol.swift

@@ -108,9 +108,7 @@ protocol ClientProxyProtocol: AnyObject {
     
     var verificationStatePublisher: CurrentValuePublisher<SessionVerificationState, Never> { get }
     
-    var homeserverReachabilityPublisher: CurrentValuePublisher<NetworkMonitorReachability, Never> { get }
-    
-    var homeserverConnectivityPublisher: CurrentValuePublisher<NetworkMonitorReachability, Never> { get }
+    var homeserverReachabilityPublisher: CurrentValuePublisher<HomeserverReachability, Never> { get }
     
     var userID: String { get }
     

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

@@ -13,11 +13,11 @@ import UIKit
 nonisolated struct MediaProvider: MediaProviderProtocol {
     private let mediaLoader: MediaLoaderProtocol
     private let imageCache: Kingfisher.ImageCache
-    private let homeserverReachabilityPublisher: CurrentValuePublisher<NetworkMonitorReachability, Never>?
+    private let homeserverReachabilityPublisher: CurrentValuePublisher<HomeserverReachability, Never>?
     
     init(mediaLoader: MediaLoaderProtocol,
          imageCache: Kingfisher.ImageCache,
-         homeserverReachabilityPublisher: CurrentValuePublisher<NetworkMonitorReachability, Never>?) {
+         homeserverReachabilityPublisher: CurrentValuePublisher<HomeserverReachability, Never>?) {
         self.mediaLoader = mediaLoader
         self.imageCache = imageCache
         self.homeserverReachabilityPublisher = homeserverReachabilityPublisher