let central = SBCentralManager()
//or
let central = SBCentralManager.shared

central.start(listener: self)
//or
central.start()

state
isConnected
isConnecting
connectedPeripherals
foundPeripherals
isBluetoothAvailable
......

func central(_ central: SBCentralManager, available: Bool) {
}

func central(_ central: SBCentralManager, didChangeState: CenterState) {
}

func central(_ central: SBCentralManager, didConnect device: Peripheral) {
}

func central(_ central: SBCentralManager, onDisconnecting device: Peripheral) {
}

func central(_ central: SBCentralManager, onConnecting device: Peripheral) {
}

func central(_ central: SBCentralManager, didDisconnect device: Peripheral, error: Error?) {
}

func central(_ central: SBCentralManager, peripheral: BLEPeripheral, didRSSIChanged RSSI: NSNumber) {
}

func central(_ central: SBCentralManager, device: BLEPeripheral, characteristic: CBCharacteristic, didReceive data: Result<Data>) {
}

SBCentralManager.enableLog = true

// !!! Scan will fail beofre bluetooth available.

central.scan(serviceUUIDs: nil,
                             allowDuplicates: false,
                             filter: { (peripheral) -> (Bool) in
                             // You can filter peripheral by name or other properties.
                             // return peripheral.name.contains("your custom bluetooth name.")
                             return true
}, sorter: { (peripheral1, peripheral2) -> (Bool) in
    // You can sort peripheral by rssi or other properties.
    return peripheral1.rssi < peripheral2.rssi
}) { (result) in
    switch result {
    case .success(let discoverPeripheral, let foundPeripheralList):
    break
    case .cancelled:
    print("Scan cancelled.")
    case .failure(let error):
    print("Scan error: \(error?.localizedDescription ?? "")")
    }
}

central.stopScan()

central.connect(peripheral: discoverPeripheral,
                timeoutInterval: 10,
                callback: { (result) in
                switch result {
                case .success(let peripheral):
                    print("Connect periphera:\(peripheral.name).")
                case .cancelled:
                    print("Connect cancelled.")
                case .failure(let error):
                    print("Connect error: \(error?.localizedDescription ?? "")")
                }
})


central.cancelConnecting()


central.disConnect(peripheral: peripheral) { (result) in
                switch result {
                case .success(let peripheral):
                    print("Disconnect periphera:\(peripheral.name).")
                case .cancelled:
                    print("Disconnect cancelled.")
                case .failure(let error):
                    print("Disconnect error: \(error?.localizedDescription ?? "")")
                }
}

name
uuid
rssi
......

peripheral.discoverServices(serviceUUIDs: nil, callback: { (result) in
    switch result {
    case .success(let services):
        print("DiscoverServices:\(services).")
    case .cancelled:
        print("DiscoverServices cancelled.")
    case .failure(let error):
        print("DiscoverServices error: \(error?.localizedDescription ?? "")")
    }
})

peripheral.discoverCharacteristics(characteristicUUIDs: nil, service: service) { (result) in
    switch result {
    case .success(let characteristics):
        print("DiscoverCharacteristics:\(String(describing: characteristics?.count)).")
    case .cancelled:
        print("Characteristics cancelled.")
    case .failure(let error):
        print("Characteristics error: \(error?.localizedDescription ?? "")")
    }
}

peripheral.writeValue(data: data,
                      characteristic: characteristic,
                      type: .withResponse)

peripheral.readRSSI()