Ordering operations in ReactiveCocoa with concurrent delegate callbacks - ios

Question

I am still trying to wrap my head around ReactiveCocoa, and one thing in particular is causing headaches. I would like to have a declarative interface to the CoreBluetooth API that lets me do something like this:
#property (nonatomic) NSNumber *registerValue;
#property (nonatomic) NSNumber *serialNumber;
RACSignal *characteristics = [[RACObserve(self, connectedPeripheral) flattenMap:^RACStream *(CBPeripheral *peripheral) {
return [peripheral rac_discoverServices:#[[CBUUID UUIDWithString:kBLEServiceUUIDString]]];
}] flattenMap:^RACStream *(CBService *service) {
return [service rac_discoverCharacteristics:nil];
}];
RACSignal *devInfoCharacteristics = [[RACObserve(self, connectedPeripheral) flattenMap:^RACStream *(CBPeripheral *peripheral) {
return [peripheral rac_discoverServices:#[[CBUUID UUIDWithString:kDevInfoServiceUUIDString]]];
}] flattenMap:^RACStream *(CBService *service) {
return [service rac_discoverCharacteristics:nil];
}];
RACSignal *registerUpdates = [[[characteristics filter:^BOOL(CBCharacteristic *characteristic) {
return ([characteristic.UUID isEqual:[CBUUID UUIDWithString:kRegisterCharacteristicUUIDString]]);
}] flattenMap:^RACStream *(CBCharacteristic *characteristic) {
return [[characteristic rac_updateNotificationState:YES] mapReplace:characteristic];
}] flattenMap:^RACStream *(CBCharacteristic *characteristic) {
return [characteristic rac_didUpdateValue];
}];
RACSignal *serialNumberSignal = [[[characteristics filter:^BOOL(CBCharacteristic *characteristic) {
return ([characteristic.UUID isEqual:[CBUUID UUIDWithString:kSerialNumberCharacteristicUUIDString]]);
}] flattenMap:^RACStream *(CBCharacteristic *characteristic) {
return [characteristic rac_didUpdateValue];
}];
RAC(self, serialNumber) = serialNumberSignal;
RAC(self, registerValue) = registerUpdates;
Now, the implementation of rac_discoverServices looks something like this (a category on CBPeripheral):
- (RACSignal *)rac_discoverServices:(NSArray *)serviceUUIDs
{
#weakify(self);
return [RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
#strongify(self);
RACDisposable *disposable = [[[[self rac_didDiscoverServices] take:1] flattenMap:^RACStream *(id value) {
return [[[self.services rac_sequence] signal] filter:^BOOL(CBService *service) {
if (!serviceUUIDs) {
return YES;
} else {
for (CBUUID *uuid in serviceUUIDs) {
if ([uuid isEqual:service.UUID]) {
return YES;
}
}
return NO;
}
}];
}] subscribe:subscriber];
[self discoverServices:serviceUUIDs];
return disposable;
}];
}
The problem is that I don't think this can work, because I don't believe the callback ordering can be guaranteed. So what I really want is to be able to ensure that the subscription to the second signal cannot issue the call to discover new services until the first signal has completed.
I understand that RACCommand will prevent concurrent operation, but I don't see a way to use it to ensure that the operations are queued.
Is there some obvious solution I am missing? The only thing I can think of is to somehow maintain a queue of calls and call discover again when the prior signal is disposed of (and I'm not certain that would work either).