Merge pull request #1119 from liveview-native/background-crash

Use `AsyncThrowingStream` to handle join replies
liveview-native · Aug 30, 2023 · 2a3df0b · 2a3df0b
2 parents 805df23 + 712250f
commit 2a3df0b
Showing 1 changed file with 31 additions and 19 deletions.
diff --git a/Sources/LiveViewNative/Coordinators/LiveViewCoordinator.swift b/Sources/LiveViewNative/Coordinators/LiveViewCoordinator.swift
@@ -278,17 +278,23 @@ public class LiveViewCoordinator<R: RootRegistry>: ObservableObject {
             }
         }
 
-        let joinResult = try await join(channel: channel)
-
-        switch joinResult {
-        case .rendered(let payload):
-            self.handleJoinPayload(renderedPayload: payload)
-        case .redirect(let liveRedirect):
-            self.url = liveRedirect.to
-            try await self.connect(domValues: domValues, redirect: true)
+        let joinTask = Task {
+            for try await joinResult in join(channel: channel) {
+                switch joinResult {
+                case .rendered(let payload):
+                    self.handleJoinPayload(renderedPayload: payload)
+                case .redirect(let liveRedirect):
+                    self.url = liveRedirect.to
+                    try await self.connect(domValues: domValues, redirect: true)
+                }
+
+                self.internalState = .connected
+            }
         }
 
-        self.internalState = .connected
+        channel.onClose { _ in
+            joinTask.cancel()
+        }
     }
 
     func disconnect() async {
@@ -312,47 +318,53 @@ public class LiveViewCoordinator<R: RootRegistry>: ObservableObject {
         case redirect(LiveRedirect)
     }
 
-    private func join(channel: Channel) async throws -> JoinResult {
-        try await withCheckedThrowingContinuation { continuation in
-            channel.join()
+    private func join(channel: Channel) -> AsyncThrowingStream<JoinResult, Error> {
+        return AsyncThrowingStream<JoinResult, Error> { [weak channel] (continuation: AsyncThrowingStream<JoinResult, Error>.Continuation) -> Void in
+            channel?.join()
                 .receive("ok") { [weak self, weak channel] message in
                     guard let channel else {
-                        continuation.resume(throwing: LiveConnectionError.viewCoordinatorReleased)
+                        continuation.finish(throwing: LiveConnectionError.viewCoordinatorReleased)
                         return
                     }
                     guard self != nil else {
                         // leave the channel so we don't get any more messages/automatic rejoins
                         if channel.isJoined {
                             channel.leave()
                         }
-                        continuation.resume(throwing: LiveConnectionError.viewCoordinatorReleased)
+                        continuation.finish(throwing: LiveConnectionError.viewCoordinatorReleased)
                         return
                     }
                     let renderedPayload = (message.payload["rendered"] as! Payload)
-                    continuation.resume(returning: .rendered(renderedPayload))
+                    continuation.yield(.rendered(renderedPayload))
                 }
                 .receive("error") { [weak self, weak channel] message in
                     guard channel != nil else {
-                        continuation.resume(throwing: LiveConnectionError.viewCoordinatorReleased)
+                        continuation.finish(throwing: LiveConnectionError.viewCoordinatorReleased)
                         return
                     }
 
                     Task { [weak self] in
                         guard let self else {
-                            continuation.resume(throwing: LiveConnectionError.viewCoordinatorReleased)
+                            continuation.finish(throwing: LiveConnectionError.viewCoordinatorReleased)
                             return
                         }
 
                         await self.disconnect()
 
                         if self.session.configuration.navigationMode.permitsRedirects,
                            let redirect = (message.payload["live_redirect"] as? Payload).flatMap({ LiveRedirect(from: $0, relativeTo: self.url) }) {
-                            continuation.resume(returning: .redirect(redirect))
+                            continuation.yield(.redirect(redirect))
                         } else {
-                            continuation.resume(throwing: LiveConnectionError.joinError(message))
+                            continuation.finish(throwing: LiveConnectionError.joinError(message))
                         }
                     }
                 }
+            channel?.onClose { _ in
+                continuation.finish()
+            }
+            continuation.onTermination = { [weak channel] termination in
+                channel?.leave()
+            }
         }
     }