Refactor connection logic

The app would crash when connection settings were changed. This
refactors the connection logic to be consistent with the rest of the
mpdclient command structure. This ultimately fixes the bug.

Persephone/AppDelegate.swift

@@ -23,9 +23,6 @@ class AppDelegate: NSObject,
   @IBOutlet weak var addSelectedSongToQueueMenuItem: NSMenuItem!
 
   func applicationDidFinishLaunching(_ aNotification: Notification) {
-    connectToMPDServer()
-    instantiateControllers()
-
     mediaKeyTap = MediaKeyTap(delegate: self)
     mediaKeyTap?.start()
 
@@ -34,22 +31,16 @@ class AppDelegate: NSObject,
         $0.uiState
       }
     }
+    
+    instantiateControllers()
+    connectToMPDServer()
   }
 
   func connectToMPDServer() {
-    let mpdServer = App.store.state.preferencesState.mpdServer
+    App.mpdServerController.connect()
-
-    App.mpdClient = MPDClient(
-      host: mpdServer.hostOrDefault,
-      port: mpdServer.portOrDefault,
-      withDelegate: App.mpdServerDelegate
-    )
-
-    App.mpdClient.connect()
   }
 
   func instantiateControllers() {
-    _ = App.mpdServerController
     _ = App.userNotificationsController
   }
 

Persephone/Components/Shared/MPDServerController.swift

@@ -11,9 +11,24 @@ import ReSwift
 
 class MPDServerController {
   init() {
-//    App.store.subscribe(self) {
+    App.mpdClient = MPDClient(withDelegate: App.mpdServerDelegate)
-//      $0.select { $0.preferencesState.mpdServer }
+    
-//    }
+    App.store.subscribe(self) {
+      $0.select { $0.preferencesState.mpdServer }
+    }
+  }
+  
+  func connect() {
+    let mpdServer = App.store.state.preferencesState.mpdServer
+
+    App.mpdClient.connect(
+      host: mpdServer.hostOrDefault,
+      port: mpdServer.portOrDefault
+    )
+  }
+  
+  func disconnect() {
+    App.mpdClient.disconnect()
   }
 }
 
@@ -21,7 +36,9 @@ extension MPDServerController: StoreSubscriber {
   typealias StoreSubscriberStateType = MPDServer
 
   func newState(state: MPDServer) {
-    App.mpdClient.disconnect()
+    guard App.mpdClient != nil else { return }
-    App.mpdClient.connect()
+    
+    disconnect()
+    connect()
   }
 }

Persephone/MPDClient/Extensions/MPDClient+Command.swift

@@ -15,6 +15,14 @@ extension MPDClient {
   ) {
     switch command {
       
+    case .connect:
+      guard let host = userData["host"] as? String,
+        let port = userData["port"] as? Int
+        else { return }
+      createConnection(host: host, port: port)
+    case .disconnect:
+      freeConnection()
+
     // Transport commands
     case .prevTrack:
       sendPreviousTrack()

Persephone/MPDClient/Extensions/MPDClient+Connection.swift

@@ -10,8 +10,7 @@ import Foundation
 import mpdclient
 
 extension MPDClient {
-  func makeConnectionOperation(host: String, port: Int) -> BlockOperation {
+  func createConnection(host: String, port: Int) {
-    BlockOperation { [unowned self] in
     guard let connection = mpd_connection_new(host, UInt32(port), 10000),
       mpd_connection_get_error(connection) == MPD_ERROR_SUCCESS
       else { return }
@@ -26,24 +25,27 @@ extension MPDClient {
 
     self.delegate?.didConnect(mpdClient: self)
     self.delegate?.didUpdateStatus(mpdClient: self, status: self.status!)
-
-      self.idle()
-    }
   }
   
-  func connect() {
+  func freeConnection() {
-    commandQueue.addOperation(connectionOperation)
-  }
-
-  func disconnect() {
     guard isConnected else { return }
     
-    noIdle()
-    commandQueue.addOperation { [unowned self] in
     self.delegate?.willDisconnect(mpdClient: self)
 
      mpd_connection_free(self.connection)
      self.isConnected = false
   }
+
+  func connect(host: String, port: Int) {
+    let commandOperation = BlockOperation() { [unowned self] in
+      self.sendCommand(command: .connect, userData: ["host": host, "port": port])
+
+      self.idle()
+    }
+    commandQueue.addOperation(commandOperation)
+  }
+  
+  func disconnect() {
+    enqueueCommand(command: .disconnect)
   }
 }

Persephone/MPDClient/MPDClient.swift

@@ -22,9 +22,8 @@ class MPDClient {
 
   let commandQueue = OperationQueue()
 
-  init(host: String, port: Int, withDelegate delegate: MPDClientDelegate?) {
+  init(withDelegate delegate: MPDClientDelegate?) {
     commandQueue.maxConcurrentOperationCount = 1
     self.delegate = delegate
-    self.connectionOperation = makeConnectionOperation(host: host, port: port)
   }
 }

Persephone/MPDClient/Models/MPDCommand.swift

@@ -10,6 +10,9 @@ import Foundation
 
 extension MPDClient {
   enum MPDCommand {
+    case connect
+    case disconnect
+    
     // Transport commands
     case prevTrack
     case nextTrack