Hi, the device we create has 2 same UUID services for battery from different sources. When I use bluecap service discovery, it automatically filter out the service. So when I use other BLE app, I will able to find lets say total 5 services, but bluecap only show 4 services due to same UUID? Is it possible to remove the filter option? If so , how can I do it?

Thank you.

Hey!

When I am reading/writing to characteristics on my BLE device, I configure the device and then start getting notified for updates to a particular characteristic (so that I can monitor a button press).

Alongside this I regularly poll the battery level and signal strength of the peripheral but whenever I try to discover new services/and or characteristics, the previous services and characteristics are removed and forgotten about. This means that when the button is pressed I see the log message come through from CoreBluetooth that a characteristic was updated, but it can't find which peripheral the characteristic belongs to.

I can see references to discoveredServices.removeAll() and discoveredCharacteristics.removeAll() in a few places.

Is there a reason that services and characteristics are removed from the Peripheral when you try to discover new ones? I'm happy to submit a PR to resolve this if desired but wanted to check beforehand.

Thanks!

This attempts to solve #51.

Specifically the steps done are:

• [x] Add new target for tvOS
• [x] Rename iOS target to include the platform
• [x] Add all parts of code that are available via tvOS APIs, which means:
  • [x] Removed the location feature (as CoreLocation doesn't provide APIs for it)
  • [x] Removed some peripheral-related initializers (see also this thread on SO)
• [x] Add tvOS-support in .podspec for Cocoapods support (pod lib lint passed)
• [x] Shared tvOS scheme for Carthage support
• [x] List tvOS as an alternative to iOS in requirements section within README

Everything should behave as before regarding iOS – the target name change shouldn't affect the framework name as I changed it not to rely on the target name (otherwise the iOS framework would have a differing name from the tvOS framework, which is usually not the expected behavior).

I'm working with a library right now from my chipset manufacturer, and trying to rewrite this and wrap it with the BlueCap framework, but I'm having trouble with the BLE messaging because I need to be able to setNotifyValue for a characteristic once I've discovered it. For example, the manufacturer's library makes this call:

[self.connectedPeripheral.peripheral
 setNotifyValue:YES
 forCharacteristic:characteristic];

This call is made after the services and characteristics have been discovered, and is basically saying, "I've found this characteristic on my peripheral, and now I want to be notified of changes to it." However, the BlueCap library wraps setNotifyValue into a private internal function, so when the characteristic is discovered, the initializer casts it to a CBCharacteristicInjectable, and the internal cbCharacteristic.isNotifying value is set to NO, and there's no way to change this after the fact, as far as I can tell. Am I missing something simple? Is there something more complex, like me needing to create a profile for the characteristics on my device? Or do I need to figure out a way to fix this and send a PR? Thanks for your help, and thanks for this awesome framework.

More of a request rather than an issue. Do you intend to add support for cocoa pods for BlueCap? It makes updates and new features / bug fixes much easier to incorporate than manually adding to projects.

Unlike in the examples where stopScanning() is called before connect(), I'd like to keep scanning for other devices after making a connection.

In didConnectPeripheral(), connectionPromise? was nil because the Peripheral in _discoveredPeripherals[] was overwritten in didDiscoverPeripheral() which always creates a new Peripheral instance.

Is it possible to keep objects in _discoveredPeripherals[] stable? Update the properties instead of replacing the object.

This will allow holding references to the Peripheral object.

I'm happy to discuss more or even coding.

As the README.md say, we can give the Future a failure callback. But for the error PeripheralError.disconnected, it just stand for the disconnection without error, which should happen when the manager actively disconnect the peripheral.

For the unexpected disconnection, such as shutting down the peripheral, exceeding the effective distance, the delegate will received a message with error in BluetoothKit. In this case, your design just put it to the failure promise.

if let error = error {
                Logger.debug("disconnecting with errors uuid=\(identifier.uuidString), name=\(self.name), error=\(error.localizedDescription), disconnection count=\(_disconnectionCount) ")
                connectionPromise?.failure(error)
            } else  {
                Logger.debug("disconnecting with no errors uuid=\(identifier.uuidString), name=\(self.name)")
                self.connectionPromise?.failure(PeripheralError.disconnected)
            }

Is there a better resolution for this condition?

There are wrong logic when called function loadRetrievedPeripheral().

1. Call func loadRetrievedPeripheral(_ peripheral: CBPeripheralInjectable) -> Peripheral
2. Created new instance of newBCPeripheral (line 262 CentralManager.swift) and it sets
   self.cbPeripheral.delegate = self (line 203 in Peripheral.swift)
3. Replaced peripheral (line 262 CentralManager.swift) and self._discoveredPeripherals[peripheral.identifier] = newBCPeripheral and it removes old peripheral and calls deinit (line 208 in Peripheral.swift) BUT it also removes delegate for new peripheral
4. As result it never calls any of peripheral delegate functions

Way to fix: Peripheral.swift

1. remove deinit { self.cbPeripheral.delegate = nil } 2 ) and replace: var delegate: CBPeripheralDelegate? { get set } with: weak var delegate: CBPeripheralDelegate? { get set }

As far as I can tell there is no way to add a CDMutableDescriptor to BlueCap's MutableCharacteristic class. The underlying CBMutableCharacteristic is not exposed either so there is no way to add the descriptors directly to the characteristic itself.

If I connect to, discover services and characteristics, notify and receive notification updates with a peripheral and I use the same central to attempt to connect and do the same with another peripheral, the state of the CentralManager is unsupported, yet if I forgo the state checking and connect anyway, it works as intended.

I am running this on an iPhone 7 Plus 256GB running iOS 10.3.2 beta 4.

Here is my code for the connection, discovery, etc.:

func connect() {
        let dataUpdateFuture = self.central.whenStateChanges().flatMap { [unowned self] state -> FutureStream<Void> in
            
            switch state {
            case .poweredOn:
                return self.peripheral.connect(connectionTimeout: 10.0)
            case .poweredOff:
                throw BLEError.poweredOff
            case .unauthorized:
                throw BLEError.unauthorized
            case .unsupported:
                throw BLEError.unsupported
            case .resetting:
                throw BLEError.resetting
            case .unknown:
                throw BLEError.unknown
            }
 
            return self.peripheral.connect(connectionTimeout: 10.0)
            }.flatMap { [unowned self] () -> Future<Void> in
                //Update UI
                self.peripheral.startPollingRSSI(period: 0.25, capacity: 10).onSuccess { rssi in
                    BLE.sharedInstance.invoke(method: { $0.didUpdateRSSI?(rssi) })
                }
                BLE.sharedInstance.invoke(method: { $0.didGetPeripheralUUID?(self.peripheral.identifier.uuidString) })
                self.uuid = self.peripheral.identifier.uuidString

                print("Discovering services")
                return self.peripheral.discoverServices([s2UUID], timeout: 10.0)
            }.flatMap { [unowned self] () -> Future<Void> in
                guard let service = self.peripheral.services(withUUID: s2UUID)?.first else {
                    throw AppError.serviceNotFound
                }
                print("Discovering characteristics")
                return service.discoverCharacteristics([rawUUID], timeout: 10.0)
            }.flatMap { [unowned self] () -> Future<Void> in
                guard let service = self.peripheral.services(withUUID: s2UUID)?.first else {
                    throw BLEError.serviceNotFound
                }
                guard let rawCharacteristic = service.characteristics(withUUID: rawUUID)?.first else {
                    throw BLEError.rawDataCharacteristicNotFound
                }
                print("Start notifying raw characteristic")
                self.rawDataCharacteristic = rawCharacteristic
                return rawCharacteristic.startNotifying()
            }.flatMap { [unowned self] () -> FutureStream<Data?> in
                guard let rawCharacteristic = self.rawDataCharacteristic else {
                    throw BLEError.rawDataCharacteristicNotFound
                }
                print("Receiving raw characteristic notification update")
                return rawCharacteristic.receiveNotificationUpdates(capacity: 30)
        }

As for errors being thrown, I have to use CBErrors to catch some of them, like so:

dataUpdateFuture.onFailure { error in
            print("Data update error: \(error)")
            switch error {
            case BLEError.serviceNotFound:
                self.disconnect()
            case PeripheralError.disconnected, PeripheralError.connectionTimeout, CBError.connectionTimeout, CBError.connectionFailed:
                self.connect()
            default:
                break
            }
        }

Hi, I'm trying to test next_release branch but I'm new in Swift, what's the new syntaxis to create a new connection and when it's successful, it could probably be something like this? Could you give me a more complete example please?

manager.startScanning(forServiceUUIDs: [CBUUID]?).flatMap(mapping: (Peripheral) throws -> Future)

Thanks in advance

From what I have read, this does not seem to be possible as part of BluetoothCore API. Has any of these capabilities been exposed as part of this project?

When the distant device application gets killed, I would like to disconnect properly from my side, I am receiving only one log from the library internals: ./Pods/BlueCapKit/BlueCapKit/Central/Peripheral.swift:peripheral(_:didModifyServices:):332

As it is not forwarded anywhere, and the Peripheral registers as the CBDelegate, I cannot handle the notification from my side. Do I have to modify the source code to forward that message or am I missing something?

Thanks for your support,

With the current library I am using for Android, I do something like this:

writeCharacteristic(callback1).enqueue() waitForNotification(callback1).enqueue()

I don't have a general callback for notifications.

This is nice because I am interested in the value only after writes, I can use a different callback for different messages to keep things organized and I can put a lot of these in a queue and nothing gets mixed up.

Is it possibly to do something like this on iOS?