next iteration of the client upgrade

Author: mobile-bungalow

Sources/LiveViewNative/Coordinators/LiveSessionCoordinator.swift

@@ -58,7 +58,6 @@ public class LiveSessionCoordinator<R: RootRegistry>: ObservableObject {
     private var liveviewClient: LiveViewClient?
     private var builder: LiveViewClientBuilder
 
-    private var liveReloadChannel: LiveViewNativeCore.LiveChannel?
     private var liveReloadListenerLoop: Task<(), any Error>?
 
     private var cancellables = Set<AnyCancellable>()
@@ -69,16 +68,10 @@ public class LiveSessionCoordinator<R: RootRegistry>: ObservableObject {
 
     deinit {
         let client = liveviewClient
-        let channel = liveReloadChannel
         Task { @MainActor in
             if let client {
                 client.shutdown()
             }
-            if let channel {
-                do {
-                  try await channel.shutdownParentSocket()
-                }
-            }
         }
     }
 
@@ -103,12 +96,8 @@ public class LiveSessionCoordinator<R: RootRegistry>: ObservableObject {
         self.init(host.url, config: config, customRegistryType: customRegistryType)
     }
 
-    public func clientChannel() -> LiveViewClientChannel? {
-         self.liveviewClient?.channel()
-     }
-
-     public func status() -> SocketStatus {
-         (try? self.liveviewClient?.status()) ?? .disconnected
+    public func status() -> LiveViewClientStatus {
+         (try? self.liveviewClient?.status()) ?? .connecting
      }
 
     /// Creates a new coordinator with a custom registry.
@@ -141,8 +130,27 @@ public class LiveSessionCoordinator<R: RootRegistry>: ObservableObject {
             .sink { [weak self] newView in
                 guard let self else { return }
                 guard let last = self.navigationPath.last else { return }
-                if let client = self.liveviewClient {
-                    last.coordinator.join(client, self.eventHandler, self.patchHandler)
+                switch newView {
+                case .disconnected:
+                    self.state = .disconnected
+                case .connecting:
+                    self.state = .connecting
+                case .reconnecting:
+                    self.state = .reconnecting
+                case .connected(channelStatus: let channelStatus):
+                    switch channelStatus {
+                        case .connected(let doc):
+                            self.state = .connected
+                        case .reconnecting:
+                            self.state = .reconnecting
+                    }
+                case .error(error: let error):
+                    self.state = .connectionFailed(error)
+                }
+                if stylesheet != nil && rootLayout != nil {
+                    if let client = self.liveviewClient {
+                        last.coordinator.join(client, newView, self.patchHandler)
+                    }
                 }
         }.store(in: &cancellables)
 
@@ -252,10 +260,8 @@ public class LiveSessionCoordinator<R: RootRegistry>: ObservableObject {
                 try await client.reconnect(originalURL.absoluteString, opts)
             } else {
                 self.liveviewClient = try await self.builder.connect(originalURL.absoluteString, opts)
-                self.navigationPath.last!.coordinator.join(self.liveviewClient!, self.eventHandler, self.patchHandler)
             }
-            
-            
+           
             self.rootLayout = try self.liveviewClient!.deadRender()
             let styleURLs = try self.liveviewClient!.styleUrls()
 
@@ -281,49 +287,15 @@ public class LiveSessionCoordinator<R: RootRegistry>: ObservableObject {
                 }
             }
 
-            self.state = .connected
-            
+            self.navigationPath.last!.coordinator.join(self.liveviewClient!, self.liveviewClient!.status(), self.patchHandler)
+           
         } catch {
+            self.rootLayout = nil
+            self.stylesheet = nil
             self.state = .connectionFailed(error)
         }
     }
-   
-    // TODO: move this error handlign into core
-    func overrideLiveReloadChannel(channel: LiveChannel) async throws {
-        if let liveReloadChannel {
-            try await liveReloadChannel.shutdownParentSocket()
-            self.liveReloadChannel = nil
-        }
-        
-        self.liveReloadChannel = channel
-        self.bindLiveReloadListener()
-    }
 
-    func bindLiveReloadListener() {
-        let eventListener = self.liveReloadChannel!.channel().events()
-        self.liveReloadListenerLoop = Task { @MainActor [weak self] in
-            while !Task.isCancelled {
-                let event =  try await eventListener.event()
-                guard let self else { return }
-                let currentTime = Date()
-                
-                guard currentTime.timeIntervalSince(lastReloadTime) >= debounceTime else {
-                    continue
-                }
-                
-                if case .user(user: "assets_change") = event.event {
-                    Task { @MainActor in
-                        await self.disconnect()
-                        self.navigationPath = [.init(url: self.url, coordinator: .init(session: self, url: self.url), navigationTransition: nil, pendingView: nil)]
-                        await self.connect()
-                        self.lastReloadTime = Date()
-                    }
-                    return
-                }
-            }
-            
-        }
-    }
 
     private func disconnect(preserveNavigationPath: Bool = false) async {
         do {
@@ -342,15 +314,12 @@ public class LiveSessionCoordinator<R: RootRegistry>: ObservableObject {
                 self.navigationPath = [self.navigationPath.first!]
             }
 
-            if self.liveReloadChannel?.channel().status() == .joined {
-                try await self.liveReloadChannel?.shutdownParentSocket()
-            }
+          
 
             if let liveReloadListenerLoop {
                 liveReloadListenerLoop.cancel()
             }
 
-            self.liveReloadChannel = nil
 
             if let client = self.liveviewClient {
                 try await client.disconnect()

Sources/LiveViewNative/Coordinators/LiveViewCoordinator.swift

@@ -34,7 +34,6 @@ public class LiveViewCoordinator<R: RootRegistry>: ObservableObject {
     @_spi(LiveForm) public private(set) weak var session: LiveSessionCoordinator<R>!
 
     private weak var liveviewClient: LiveViewClient?
-    private var channel: LiveViewClientChannel?
 
      var url: URL
 
@@ -113,7 +112,7 @@ public class LiveViewCoordinator<R: RootRegistry>: ObservableObject {
             throw LiveSocketError.DisconnectionError
         }
 
-        if let replyPayload = try await channel?.call(event, payload) {
+        if let replyPayload = try await liveviewClient?.call(event, payload) {
             return try await handleEventReplyPayload(replyPayload)
         } else {
             return nil
@@ -126,7 +125,7 @@ public class LiveViewCoordinator<R: RootRegistry>: ObservableObject {
             throw LiveSocketError.DisconnectionError
         }
 
-        if let replyPayload = try await channel?.call(event, payload) {
+        if let replyPayload = try await liveviewClient?.call(event, payload) {
             return replyPayload
         } else {
             return nil
@@ -245,9 +244,10 @@ public class LiveViewCoordinator<R: RootRegistry>: ObservableObject {
     }
 
 
-    func bindDocumentListener() {
-        let handler = SimplePatchHandler()
-        patchHandlerCancellable = handler.patchEventSubject.sink { [weak self] patch in
+    func bindDocumentListener(_ handler: SimplePatchHandler) {
+        patchHandlerCancellable = handler.patchEventSubject
+            .receive(on: DispatchQueue.main)
+            .sink { [weak self] patch in
             switch patch.data {
             case .root:
                 // when the root changes, update the `NavStackEntry` itself.
@@ -278,70 +278,57 @@ public class LiveViewCoordinator<R: RootRegistry>: ObservableObject {
                 }
             }
         }
-        self.document?.setEventHandler(handler)
     }
 
     func join(_ client: LiveViewNativeCore.LiveViewClient,
-              _ eventListener: SimpleEventHandler,
+              _ initial_status: LiveViewClientStatus,
               _ docHandler: SimplePatchHandler
     ) {
         self.liveviewClient = client
-        self.channel = client.channel()
-        self.document = try! client.document()
-        
-         eventListener.channelStatusSubject
-            .receive(on: DispatchQueue.main)
-            .sink { event in
-            self.internalState = switch event.status {
-            case .joined:
-                .connected
-            case .joining, .waitingForSocketToConnect, .waitingToJoin:
-                .connecting
-            case .waitingToRejoin:
-                .reconnecting
-            case .leaving, .left, .shuttingDown, .shutDown:
-                .disconnected
-            }
-        }.store(in: &eventHandlers)
-        
-        
-         docHandler.patchEventSubject
-            .receive(on: DispatchQueue.main)
-            .sink { event in
-            switch event.data {
-            case .root:
-                // when the root changes, update the `NavStackEntry` itself.
-                self.objectWillChange.send()
-            case .leaf:
-                // text nodes don't have their own views, changes to them need to be handled by the parent Text view
-                // note: aren't these branches the same?
-                if event.parent != nil {
-                    self.elementChanged(event.node).send()
-                } else {
-                    self.elementChanged(event.node).send()
+        handleViewReloadStatus(initial_status)
+        self.bindDocumentListener(docHandler)
+    }
+    
+    
+    func handleViewReloadStatus(_ status: LiveViewClientStatus) {
+        switch status {
+            case .disconnected:
+                 self.internalState = .disconnected
+            case .connecting:
+                self.internalState = .connecting
+            case .error(error: let error):
+                self.internalState = .connectionFailed(error)
+            case .reconnecting:
+                self.internalState = .setup
+            case .connected(channelStatus: let channelStatus):
+               switch channelStatus {
+                case .connected(let document):
+                    self.document = document
+                    do {
+                        if case let .jsonPayload(.object(payload)) = try self.liveviewClient?.joinPayload() {
+                            self.handleEvents(payload["rendered"]!)
+                        }
+                        self.internalState = .connected
+                    } catch {
+                       self.internalState = .connectionFailed(error)
+                    }
+                case .reconnecting:
+                    do {
+                        guard let document = try self.liveviewClient?.document() else {
+                            self.internalState = .connecting
+                            return
+                        }
+                        self.document = document
+                        self.internalState = .reconnecting
+                    } catch {
+                        self.internalState = .connecting
+                    }
                 }
-            case .nodeElement:
-                // when a single element changes, send an update only to that element.
-                self.elementChanged(event.node).send()
-            }
-        }.store(in: &eventHandlers)
-
-        
-
-        
-        switch try! client.joinPayload() {
-        case let .jsonPayload(.object(payload)):
-            self.handleEvents(payload["rendered"]!)
-        default:
-            fatalError()
         }
-        
-        self.internalState = .connected
     }
-    
+
     func disconnect() {
-        self.liveviewClient = nil
-        self.channel = nil
         self.internalState = .setup
+        self.liveviewClient = nil
     }
 }

Sources/LiveViewNative/Live/LiveView.swift

@@ -207,16 +207,6 @@ public struct LiveView<
         case .connecting:
             return .connecting
         case let .connectionFailed(error):
-            
-            if let error = error as? LiveViewNativeCore.LiveSocketError,
-               case let .ConnectionError(connectionError) = error {
-                if let channel = connectionError.livereloadChannel {
-                    Task { @MainActor [weak session] in
-                        try await session?.overrideLiveReloadChannel(channel: channel)
-                    }
-                }
-            }
-            
             return .error(error)
         case .setup:
             return .connecting