Proper way to wait for iOS Swift CBPeripheralDelegate to complete?

Question

When doing Bluetooth communications one is often placed in a situation where one does a call which gets a response in a delegate, for example the characteristic discovery shown below:

func discoverCharacteristics(device: CBPeripheral)
{
    servicesCount = device.services!.count

    for service in device.services!
    {
        print("Discovering characteristics for service \(service.uuid)")
        device.discoverCharacteristics([], for: service)
    }
}

Now this discovery is not for a specific device but for health devices following the Bluetooth SIG services/profiles, so I don't know exactly what services they might have and I don't know how many characteristics might be in each service. The method is asynchronous and the answers are signaled in the following delegate method:

// Discovered Characteristics event
func peripheral(_ peripheral: CBPeripheral, didDiscoverCharacteristicsFor service: CBService, error: Error?)
{
    for characteristic in service.characteristics!
    {
        print("Found characteristic \(characteristic.uuid)")
    }
    servicesCount = servicesCount - 1;
    print("Characteristics sets left: \(servicesCount)")
    if servicesCount == 0
    {
        print ("Found all characteristics")
        DispatchQueue.main.async{
            self.btleManager!.btleManagerDelegate.statusEvent(device: peripheral, statusEvent: Btle.CHARACTERISTICS_DISCOVERED)
        }
        self.device = peripheral
        self.handleMds()
    }
}

Now I need to wait until the discovery is done before I can take the next step because what I do next often depends on what I got. In Java and on Android what I do is wait on a CountDownLatch in the calling method and I signal the latch in the callback to release that wait.

The iOS equivalent of the CountDownLatch seems to be the DispatchSemaphore. However, doing so apparently blocks the system and no delegate ever gets called. SO what I have done (as shown in the code above) is to initialize a variable servicesCount with the number of services and in the delegate callback decrement it each time it is signaled. When it gets to zero I am done and then I do the next step.

This approach works but it seems hacky; it can't be correct. And its starting to get really messy when I need to do several reads of the DIS characteristics, the features, the various time services, etc. So what I would like to know is what is the proper method to wait for a delegate to get signaled before moving forward? Recall I do not know what services or characteristics these devices might have.

Answer 1

First of all, if you already have an implementation with CountDownLatch for Android, you may just do the same implementation for iOS. Yes, Swift doesn't have a built-in CountDownLatch, but nice folks from Uber created a good implementation.

Another option is to rely on a variable, like you do, but make it atomic. There are various implementations available online, including one in the same Uber library. Another example is in RxSwift library. There are many other variations. Atomic variable will provide a thread-safety to variable's read/write operations.

But probably the most swifty way is to have a DispatchGroup. Will look something like this:

let dispatchGroup = DispatchGroup() // instance-level definition

// ...

func discoverCharacteristics
{
    for service in device.services!
    {
        dispatchGroup.enter() 
        // ...
    }

    dispatchGroup.notify(queue: .main) {

        // All done
        print ("Found all characteristics")
        DispatchQueue.main.async{
            self.btleManager!.btleManagerDelegate.statusEvent(device: peripheral, statusEvent: Btle.CHARACTERISTICS_DISCOVERED)
        }
        self.device = peripheral
        self.handleMds()
    }

// ...

func peripheral(_ peripheral: CBPeripheral, didDiscoverCharacteristicsFor service: CBService, error: Error?)
{
    // ...
    dispatchGroup.leave()
}

In other words, you enter the group when you are about to submit a request, you leave it when request is processed. When all items left the group, notify will execute with the block you provided.