Get asynchronous method using GCD and semaphores - objective-c

Question

I'm using CoreBluetooth to connect and exchange data with a peripheral device using Bluetooth Low Energy. To connect to my peripheral I'm using the following method (for clarity, manager is an instance of the CBCentralManager class).
- (void)connectPeripheral:(CBPeripheral *)peripheral {
// Connects with the peripheral
[manager connectPeripheral:peripheral options:nil];
}
Now I wish to write the asynchronous version of this method using Grand Central Dispatch, blocks and semaphores. I would like to have a version that times out within a specific time interval. First I defined this method:
void dispatchAsyncWithCompletionAndTimeout(dispatch_queue_t queue, int64_t timeoutInNanoseconds,
dispatch_block_t block, dispatch_block_t completionBlock,
dispatch_block_t timeoutBlock) {
NSCParameterAssert(queue);
NSCParameterAssert(timeoutInNanoseconds >= 0);
NSCParameterAssert(block);
dispatch_async(queue, ^{
dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
dispatch_time_t timeoutTime = dispatch_time(DISPATCH_TIME_NOW, timeoutInNanoseconds);
dispatch_async(queue, ^{
long timedOut = dispatch_semaphore_wait(semaphore, timeoutTime);
if (timedOut) {
if (timeoutBlock) {
timeoutBlock();
}
} else if (completionBlock) {
completionBlock();
}
});
block();
dispatch_semaphore_signal(semaphore);
});
}
This function basically contains three blocks: the first is the action block (e.g. connect) and the second and third one are the handler blocks which should be called whether the action code is performed within or after the timeout expiration, respectively.
What I did next is to turn my connectPeripheral: method into an asynchronous method by wrapping it inside the following method:
- (void)connectPeripheralAnsync:(CBPeripheral *)peripheral withinTimeout:(NSInteger)timeout {
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatchAsyncWithCompletionAndTimeout(queue, (int64_t)timeout * NSEC_PER_SEC, ^{
[self connectPeripheral:peripheral];
}, ^{
NSLog(#"Peripheral discovered");
}, ^{
NSLog(#"Time runned out");
});
}
Unfortunately my third block never gets called, even if no peripheral could be discovered by the manager until the timeout expires. Where do I fail?

Answer 1

Looks like there's no problems with GCD
i get you code and remade it a little bit to check timeout stuff easy, so changing secsForTask and secsForTimeout I can check what called:
unsigned int secsForTask = 3;
unsigned int secsForTimeout = 2;
dispatch_queue_t queue = dispatch_queue_create("com.test.111", DISPATCH_QUEUE_CONCURRENT);
int64_t timeoutInNanoseconds = secsForTimeout * NSEC_PER_SEC;
dispatch_async(queue, ^{
dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
dispatch_time_t timeoutTime = dispatch_time(DISPATCH_TIME_NOW, timeoutInNanoseconds);
dispatch_block_t timeoutBlock = ^{
NSLog(#"timeout");
};
dispatch_block_t completionBlock = ^{
NSLog(#"completion");
};
dispatch_block_t block = ^{
NSLog(#"block start");
sleep(secsForTask);
NSLog(#"block end");
};
dispatch_async(queue, ^{
long timedOut = dispatch_semaphore_wait(semaphore, timeoutTime);
if (timedOut) {
if (timeoutBlock) {
timeoutBlock();
}
} else if (completionBlock) {
completionBlock();
}
});
block();
dispatch_semaphore_signal(semaphore);
});
on secsForTask = 3 and secsForTimeout = 2
block start
timeout
block end
on secsForTask = 1 and secsForTimeout = 2
block start
block end
completion
probably you have to check if everything is ok with your timeout, so you don't pass in method connectPeripheralAnsync:withinTimeout: timeout in nanosecs.

Answer 2

-[CBCentralManager connectPeripheral: options:] method is a non-block async method.
so, this method call alway pass through next line, immediately.
in your dispatchAsyncWithCompletionAndTimeout(...) method case.
the block that contains "-[CBCentralManager connectPeripheral: options:]" executed.
and then dispatch_semaphore_signal(semaphore); executed without blocking thread.
so, you always cannot get timeout.
-[CBCentralManager connectPeripheral: options:] call will response with
-[CBCentralDelegate centralManager: didConnect:] when connected successfully.
so, you should approach differently.
dispatch_semaphore_signal(semaphore); should call on -[CBCentralDelegate centralManager: didConnect:].