Add a more robust reconnection setup so that even if the Pusher servers

close the websocket connection then reconnection attempts will be made

Author: hamchapman

README.md

@@ -17,6 +17,8 @@ What else would you want? Head over to the example app [ViewController.swift](ht
 * [Installation](#installation)
 * [Configuration](#configuration)
 * [Connection](#connection)
+  * [Connection state changes](#connection-state-changes)
+  * [Reconnection](#reconnection)
 * [Subscribing to channels](#subscribing)
 * [Binding to events](#binding-to-events)
   * [Globally](#global-events)
@@ -204,6 +206,23 @@ class ViewController: UIViewController, ConnectionStateChangeDelegate {
 }
 ```
 
+### Reconnection
+
+There are three main ways in which a disconnection can occur:
+
+  * The client explicitly calls disconnect and a close frame is sent over the websocket connection
+  * The client experiences some form of network degradation which leads to a heartbeat (ping/pong) message being missed and thus the client disconnects
+  * The Pusher server closes the websocket connection; typically this will only occur during a restart of the Pusher socket servers and an almost immediate reconnection should occur
+
+In the case of the first type of disconnection the library will (as you'd hope) not attempt a reconnection.
+
+If there is network degradation that leads to a disconnection then the library has the [Reachability](https://github.com/ashleymills/Reachability.swift) library embedded and will be able to automatically determine when to attempt a reconnect based on the changing network conditions.
+
+If the Pusher servers close the websocket then the library will attempt to reconnect (by default) a maximum of 6 times, with an exponential backoff. The value of `reconnectAttemptsMax` is a public property on the `PusherConnection` and so can be changed if you wish.
+
+All of this is the case if you have the client option of `autoReconnect` set as `true`, which it is by default. If the reconnection strategies are not suitable for your use case then you can set `autoReconnect` to `false` and implement your own reconnection strategy based on the connection state changes.
+
+
 ## Subscribing
 
 ### Public channels

Source/PusherConnection.swift

@@ -22,6 +22,9 @@ public class PusherConnection {
     public var userDataFetcher: (() -> PusherUserData)?
     public var debugLogger: ((String) -> ())?
     public weak var stateChangeDelegate: ConnectionStateChangeDelegate?
+    public var reconnectAttemptsMax: Int = 6
+    public var reconnectAttempts: Int = 0
+    private var reconnectTimer: NSTimer? = nil
     internal var reconnectOperation: NSOperation?
 
     public lazy var reachability: Reachability? = {
@@ -185,6 +188,7 @@ public class PusherConnection {
             updateConnectionState(.Connecting)
             self.socket.connect()
             if self.options.autoReconnect {
+                // can call this multiple times and only one notifier will be started
                 _ = try? reachability?.startNotifier()
             }
         }
@@ -278,6 +282,11 @@ public class PusherConnection {
                 updateConnectionState(.Connected)
                 self.socketId = socketId
 
+                // cancel any other outstanding reconnect attempts
+                self.reconnectOperation?.cancel()
+                self.reconnectAttempts = 0
+                self.reconnectTimer?.invalidate()
+
                 for (_, channel) in self.channels.channels {
                     if !channel.subscribed {
                         if !self.authorize(channel) {
@@ -356,7 +365,6 @@ public class PusherConnection {
             if let jsonData = data, jsonObject = try NSJSONSerialization.JSONObjectWithData(jsonData, options: []) as? [String : AnyObject] {
                 return jsonObject
             } else {
-                // TODO: Move below
                 print("Unable to parse string from WebSocket: \(string)")
             }
         } catch let error as NSError {
@@ -656,6 +664,24 @@ public class PusherConnection {
                 )
             }
     }
+
+    /**
+        Attempt to reconnect triggered by a disconnection
+    */
+    @objc internal func attemptReconnect() {
+        if reconnectAttempts < reconnectAttemptsMax && connectionState != .Connected {
+            connect()
+            reconnectAttempts += 1
+            let timeInterval = Double(reconnectAttempts * reconnectAttempts) * 2.0
+            reconnectTimer = NSTimer.scheduledTimerWithTimeInterval(
+                timeInterval,
+                target: self,
+                selector: #selector(attemptReconnect),
+                userInfo: nil,
+                repeats: false
+            )
+        }
+    }
 }
 
 public enum ConnectionState {

Source/PusherWebsocketDelegate.swift

@@ -7,7 +7,6 @@
 //
 
 extension PusherConnection: WebSocketDelegate {
-    // MARK: WebSocketDelegate Implementation
 
     /**
         Delegate method called when a message is received over a websocket
@@ -31,7 +30,6 @@ extension PusherConnection: WebSocketDelegate {
         - parameter error: The error, if one exists, when disconnected
     */
     public func websocketDidDisconnect(ws: WebSocket, error: NSError?) {
-
         updateConnectionState(.Disconnected)
         for (_, channel) in self.channels.channels {
             channel.subscribed = false
@@ -45,7 +43,7 @@ extension PusherConnection: WebSocketDelegate {
         print("Websocket is disconnected. Error: \(error.localizedDescription)")
 
         // Reconnect if possible
-        if self.options.autoReconnect {
+        if self.options.autoReconnect && reconnectAttempts == 0 {
             if let reachability = self.reachability where reachability.isReachable() {
                 let operation = NSBlockOperation {
                     self.socket.connect()
@@ -58,6 +56,8 @@ extension PusherConnection: WebSocketDelegate {
                 self.reconnectOperation?.cancel()
                 self.reconnectOperation = operation
             }
+
+            attemptReconnect()
         }
     }