Question

我现在正在开发一个适用于BLE，后端服务器和位置的应用。我正面临一个问题，我不知道如何摆脱人们所说的＆＃34;回调地狱＆＃34;。 iOS中的整个CoreBluetooth框架都基于委托模式，直到你可以使用CBPeripheral必须至少进行3次回调：

DidConnectToPeripheral
DidDiscoverServices
DidDiscoverCharacteristics

但实际上可能会有更多，并且您对设备采取的每个操作都将作为对其中一个功能的回调而返回。现在，当我想要＆＃34; Rent＆＃34;这个产品，我必须连接到它，连接后发送请求到服务器并获得用户的当前位置，之后一切都发生了我必须在蓝牙设备写一个值并得到确认。这不会那么困难，但不幸的是，这些阶段中的每一个都是可用的，因此需要添加错误处理。更不用说实现超时了。

我相信我并不是唯一能解决这些问题的人，因此我环顾四周，找到了两件可能有帮助的事情：

高级NSOperations在wwdc 2015上发表演讲，但在尝试了4天后才开始工作，似乎代码太过错误。
Promisekit但我找不到一种方法来包装CoreBluetooth。

拥有更复杂应用程序的人如何应对此问题？在swift或objc。

一些有问题的示例代码：

-(void)startRentalSessionWithLock:(DORLock *)lock timeOut:(NSTimeInterval)timeout forSuccess:(void (^)(DORRentalSession * session))successBlock failure:(failureBlock_t)failureBlock{
    //we set the block to determine what happens
    NSAssert(lock.peripheral, @"lock has to have peripheral to connect to");
    if (!self.rentalSession) {
        self.rentalSession = [[DORRentalSession alloc] initWithLock:nil andSessionDict:@{} active:NO];
    }
    self.rentalSession.lock = lock;
    [self connectToLock:self.rentalSession.lock.peripheral timeOut:timeout completionBlock:^(CBPeripheral *peripheral, NSError *error) {

        self.BTConnectionCompleted = nil;
        if (!error) {
            [[INTULocationManager sharedInstance] requestLocationWithDesiredAccuracy:INTULocationAccuracyHouse timeout:1 delayUntilAuthorized:YES block:^(CLLocation *currentLocation, INTULocationAccuracy achievedAccuracy, INTULocationStatus status) {
                if (status == INTULocationStatusSuccess || status == INTULocationStatusTimedOut) {
                    [self startServerRentalForSessionLockWithUserLocation:currentLocation.coordinate forSuccess:^(DORRentalSession *session) {
                        if (self.rentalSession.lock.peripheral && self.rentalSession.lock.peripheral.state == CBPeripheralStateConnected) {
                            [self.rentalSession.lock.peripheral setNotifyValue:YES forCharacteristic:self.rentalSession.lock.charectaristics.sensorCharacteristic];
                        }else{
                            //shouldnt come here
                        }

                        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(0.5 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
                            if (self.rentalSession.lock.peripheral.state == CBPeripheralStateConnected) {
                                !self.rentalSession.lock.open ? [self sendUnlockBLECommandToSessionLock] : nil;
                                if (successBlock) {
                                    successBlock(session);
                                }
                            }else{
                                [self endCurrentRentalSessionWithLocation:self.rentalSession.lock.latLng andPositionAcc:@(1) Success:^(DORRentalSession *session) {
                                    if (failureBlock) {
                                        failureBlock([[NSError alloc] initWithDomain:DonkeyErrorDomain code:46 userInfo:@{NSLocalizedDescriptionKey:@"Could't connect to lock"}],200);
                                    }
                                } failure:^(NSError *error, NSInteger httpCode) {
                                    if (failureBlock) {
                                        failureBlock([[NSError alloc] initWithDomain:DonkeyErrorDomain code:45 userInfo:@{NSLocalizedDescriptionKey:@"fatal error"}],200);
                                    }
                                }];

                            }
                        });

                    } failure:^(NSError *error, NSInteger httpCode) {
                        if (failureBlock) {
                            failureBlock(error,httpCode);
                        }
                    }];

                }else{
                    NSError *gpsError = [self donkeyGPSErrorWithINTULocationStatus:status];
                    if (failureBlock) {
                        failureBlock(gpsError,200);
                    }
                }
            }];
        }else{
            if (failureBlock) {
                failureBlock(error,200);
            }
        }

    }];
}

Answer 1

要摆脱这种嵌套调用，您可以使用GCD组+串行执行队列：

dispatch_queue_t queue = ddispatch_queue_create("com.example.queue", NULL);
dispatch_group_t group = dispatch_group_create();

// Add a task to the group
dispatch_group_async(group, queue, ^{
   // Some asynchronous work
});

// Make dispatch_group_async and dispatch_group_sync calls here

// Callback to be executed when all scheduled tasks are completed.
dispatch_group_notify(serviceGroup,dispatch_get_main_queue(),^{
    // Do smth when everything has finished
});

// wait for all tasks to complete
dispatch_group_wait(group, DISPATCH_TIME_FOREVER);

基于GCD组的其他解决方案描述为here

目标c

1 个答案: