fix

nerzh · Mar 17, 2020 · 7231e51 · 7231e51
1 parent a7d090b
commit 7231e51
Show file tree

Hide file tree

Showing 2 changed files with 16 additions and 35 deletions.
diff --git a/Sources/ActionCableSwift/ACChannel.swift b/Sources/ActionCableSwift/ACChannel.swift
@@ -21,7 +21,6 @@ public class ACChannel {
     public var bufferingIfDisconnected = false
     public var subscriptionParams: [String: Any]
 
-    private let channelConcurrentQueue = DispatchQueue(label: "com.ACChannel.Conccurent", attributes: .concurrent)
     private let channelSerialQueue = DispatchQueue(label: "com.ACChannel.SerialQueue")
 
     /// callbacks
@@ -166,29 +165,25 @@ public class ACChannel {
     }
 
     private func executeCallback(callbacks: [ACResponseCallback], message: ACMessage) {
-        channelConcurrentQueue.async { [weak self] in
+        channelSerialQueue.async { [weak self] in
             guard let self = self else { return }
             for closure in callbacks {
-                self.channelConcurrentQueue.async {
-                    closure(self, message)
-                }
+                closure(self, message)
             }
         }
     }
 
     private func executeCallback(callbacks: [ACResponseCallbackWithOptionalMessage]) {
-        channelConcurrentQueue.async { [weak self] in
+        channelSerialQueue.async { [weak self] in
             guard let self = self else { return }
             for closure in callbacks {
-                self.channelConcurrentQueue.async {
-                    closure(self, nil)
-                }
+                closure(self, nil)
             }
         }
     }
 
     private func flushBuffer() {
-        channelConcurrentQueue.async { [weak self] in
+        channelSerialQueue.async { [weak self] in
             guard let self = self else { return }
             while let closure = self.actionsBuffer.popLast() {
                 closure()

diff --git a/Sources/ActionCableSwift/ActionCableSwift.swift b/Sources/ActionCableSwift/ActionCableSwift.swift
@@ -97,22 +97,18 @@ public final class ACClient {
         ws.onConnected = { [weak self] headers in
             guard let self = self else { return }
             self.isConnected = true
-            self.clientConcurrentQueue.async {
+            self.clientConcurrentQueue.async { [headers] in
                 for closure in self.onConnected {
-                    self.clientConcurrentQueue.async {
-                        closure(headers)
-                    }
+                    closure(headers)
                 }
             }
         }
         ws.onDisconnected = { [weak self] reason in
             guard let self = self else { return }
             self.isConnected = false
-            self.clientConcurrentQueue.async {
+            self.clientConcurrentQueue.async { [reason] in
                 for closure in self.onDisconnected {
-                    self.clientConcurrentQueue.async {
-                        closure(reason)
-                    }
+                    closure(reason)
                 }
             }
         }
@@ -121,49 +117,39 @@ public final class ACClient {
             self.isConnected = false
             self.clientConcurrentQueue.async {
                 for closure in self.onCancelled {
-                    self.clientConcurrentQueue.async {
-                        closure()
-                    }
+                    closure()
                 }
             }
         }
         ws.onText = { [weak self] text in
             guard let self = self else { return }
-            self.clientConcurrentQueue.async {
+            self.clientConcurrentQueue.async { [text] in
                 for closure in self.onText {
-                    self.clientConcurrentQueue.async {
-                        closure(text)
-                    }
+                    closure(text)
                 }
             }
         }
         ws.onBinary = { [weak self] data in
             guard let self = self else { return }
-            self.clientConcurrentQueue.async {
+            self.clientConcurrentQueue.async { [data] in
                 for closure in self.onBinary {
-                    self.clientConcurrentQueue.async {
-                        closure(data)
-                    }
+                    closure(data)
                 }
             }
         }
         ws.onPing = { [weak self] in
             guard let self = self else { return }
             self.clientConcurrentQueue.async {
                 for closure in self.onPing {
-                    self.clientConcurrentQueue.async {
-                        closure()
-                    }
+                    closure()
                 }
             }
         }
         ws.onPong = { [weak self] in
             guard let self = self else { return }
             self.clientConcurrentQueue.async {
                 for closure in self.onPong {
-                    self.clientConcurrentQueue.async {
-                        closure()
-                    }
+                    closure()
                 }
             }
         }