         self.connect(peerWithId: peripheral.identifier)
     }
     
-    public final func centralManager(_ central: CBCentralManager, didFailToConnect peripheral: CBPeripheral, error: Error?) {
+    public final func centralManager(
+        _ central: CBCentralManager,
+        didFailToConnect peripheral: CBPeripheral,
+        error: Error?)
+    {
         if let err = error, self.logLevel == .verbose { print(print("\(#function)\n\(err)\n")) }
         
         if let e = error {

        }
    }
    
    private func startScaningForPeripherals(minRSSI: Int) {
        self.minRSSI = minRSSI
        
        guard !self.centralManager.isScanning else { return }
        
        self.ensure(centralManagerHasState: .poweredOn) { result in
            switch result {
            case .error(let err): self.delegate?.clink(self, didCatchError: err)
            case .success: self.centralManager.scanForPeripherals(withServices: [self.serviceId], options: nil)
            }
        }
    }
    
    private func startAdvertisingPeripheral() {
        self.ensure(peripheralManagerHasState: .poweredOn) { result in
            switch result {
            case .error(let err): self.delegate?.clink(self, didCatchError: err)
            case .success: self.peripheralManager.startAdvertising([CBAdvertisementDataServiceUUIDsKey: [self.serviceId]])
            }
        }
    }
    
    // MARK: - PUBLIC METHODS
    
    /**
     Calling this method will cause Clink to begin scanning for eligible peers.
     When the first eligible peer is found, Clink with archive its identifyer and attempt to connect to it.
     Should the peer become disconnected, clink with attempt to reestablish it's connection untill the archived refrence to the peer is removed by the user.
     For a remote peer to become eligible for discovery, it must also be scanning and in close physical proximity (a few inches)
     */
    public func startPairing(completion: @escaping (Clink.OpperationResult<ClinkPeer>) -> ()) {
        let taskTimer = Timer.scheduledTimer(withTimeInterval: 30, repeats: false) { [weak self] _ in

            activeTask.completion(Clink.OpperationResult.error(.pairingOpperationTimeout))
        }
        
        self.activePairingTask = PairingTask(
            timer: taskTimer,
            remotePeripheral: nil,
            remoteCentral: nil,
            completion: completion)
        self.startScaningForPeripherals(minRSSI: self.minRSSI)
        self.startAdvertisingPeripheral()
    }
