|
|
#import <UIKit/UIKit.h>
|
#import "CBMoralManager.h"
|
#import "CBPeripheralExt.h"
|
#import "ResourceHandler.h"
|
#import "Utilities.h"
|
|
/*!
|
* @class CBMoralManager
|
*
|
* @discussion Class to co-ordinate all the peripheral related operations
|
*
|
*/
|
|
@interface CBMoralManager () <CBCentralManagerDelegate, CBPeripheralDelegate>
|
{
|
CBCentralManager *centralManager;
|
NSMutableArray *peripheralListArray;
|
|
void (^cbCommunicationHandler)(BOOL success, NSError *error);
|
BOOL isTimeOutAlert;
|
}
|
@end
|
|
@implementation CBMoralManager
|
|
@synthesize cbCharacteristicDelegate;
|
@synthesize myPeripheral;
|
@synthesize myService;
|
@synthesize myCharacteristic;
|
@synthesize myCharacteristic2;
|
@synthesize serviceUUIDDict;
|
@synthesize cbDiscoveryDelegate;
|
@synthesize foundPeripherals;
|
@synthesize foundServices;
|
@synthesize characteristicDescriptors;
|
@synthesize characteristicProperties;
|
@synthesize bootLoaderFilesArray;
|
|
|
#define k_SERVICE_UUID_PLIST_NAME @"ServiceUUIDPList"
|
|
#pragma mark - Singleton Methods
|
|
+ (id)sharedManager {
|
static CBMoralManager *sharedMyManager = nil;
|
static dispatch_once_t onceToken;
|
dispatch_once(&onceToken, ^{
|
sharedMyManager = [[self alloc] init];
|
});
|
return sharedMyManager;
|
}
|
|
- (id)init {
|
if (self = [super init])
|
{
|
centralManager = [[CBCentralManager alloc] initWithDelegate:self queue:nil];
|
foundPeripherals = [[NSMutableArray alloc] init];
|
foundServices = [[NSMutableArray alloc] init];
|
peripheralListArray = [[NSMutableArray alloc] init];
|
serviceUUIDDict = [NSMutableDictionary dictionaryWithDictionary:[ResourceHandler getItemsFromPropertyList:k_SERVICE_UUID_PLIST_NAME]];
|
bootLoaderFilesArray = nil;
|
}
|
return self;
|
}
|
|
|
#pragma mark - Discovery
|
/* Discovery */
|
/****************************************************************************/
|
|
/*!
|
* @method startScanning
|
*
|
* @discussion To scans for peripherals that are advertising services.
|
*
|
*/
|
|
- (void) startScanning
|
{
|
NSLog(@"-------------------->startScanning");
|
|
if((NSInteger)[centralManager state] == CBCentralManagerStatePoweredOn)
|
{
|
[cbDiscoveryDelegate bluetoothStateUpdatedToState:YES];
|
NSDictionary *options=[NSDictionary dictionaryWithObjectsAndKeys:[NSNumber numberWithBool:NO],CBCentralManagerScanOptionAllowDuplicatesKey, nil];
|
[centralManager scanForPeripheralsWithServices:nil options:options];
|
}
|
else if ([centralManager state] == CBCentralManagerStateUnsupported)
|
{
|
[Utilities alert:@"CySmart" Message:@"This device does not support Bluetooth Low Energy"];
|
}
|
}
|
|
|
/*!
|
* @method stopScanning
|
*
|
* @discussion To stop scanning for peripherals.
|
*
|
*/
|
|
- (void) stopScanning
|
{
|
|
[centralManager stopScan];
|
}
|
|
|
/*!
|
* @method peripheralWithPeripheral:advertisementData:RSSI
|
*
|
* @param peripheral A <code>CBPeripheral</code> object.
|
* @param advertisementData A dictionary containing any advertisement and scan response data.
|
* @param RSSI The current RSSI of <i>peripheral</i>, in dBm. A value of <code>127</code> is reserved and indicates the RSSI
|
* was not available.
|
*
|
* @discussion The methods handles the peripherals are to be displayed or not in the BLE Device List.
|
Each time a new peripheral dicover will invoke [discoveryDidRefresh] method.
|
*
|
*/
|
|
-(void)peripheralWithPeripheral:(CBPeripheral *)peripheral advertisementData:(NSDictionary *)advertisementData RSSI:(NSNumber *)RSSI
|
{
|
|
if (![peripheralListArray containsObject:peripheral])
|
{
|
if(peripheral.state == CBPeripheralStateConnected)
|
{
|
}
|
else
|
{
|
//Printing description of newPeriPheral->mAdvertisementData:
|
//{
|
// kCBAdvDataIsConnectable = 1;
|
// kCBAdvDataLocalName = MORAL;
|
// kCBAdvDataServiceData = {
|
// "0003CBBB-0000-1000-8000-00805F9B0131" = <bbcb>;
|
// };
|
//}
|
|
CBPeripheralExt *newPeriPheral = [[CBPeripheralExt alloc] init];
|
newPeriPheral.mPeripheral = [peripheral copy];
|
newPeriPheral.mAdvertisementData = [advertisementData copy];
|
newPeriPheral.mRSSI = [RSSI copy];
|
[peripheralListArray addObject:peripheral];
|
[foundPeripherals addObject:newPeriPheral];
|
[cbDiscoveryDelegate discoveryDidRefresh];
|
}
|
}
|
|
}
|
|
// - This is called with the CBPeripheral class as its main input parameter. This contains the information about a BLE peripheral.
|
- (void)centralManager:(CBCentralManager *)central didDiscoverPeripheral:(CBPeripheral *)peripheral advertisementData:(NSDictionary *)advertisementData RSSI:(NSNumber *)RSSI
|
{
|
[self peripheralWithPeripheral:peripheral advertisementData:advertisementData RSSI:RSSI];
|
}
|
|
#pragma mark - Connection/Disconnection
|
|
/*!
|
* @method cancelTimeOutAlert
|
*
|
* @discussion Method to cancel timeout alert
|
*
|
*/
|
-(void)cancelTimeOutAlert
|
{
|
[NSObject cancelPreviousPerformRequestsWithTarget:self selector:@selector(timeOutMethodForConnect) object:nil];
|
}
|
|
/*!
|
* @method timeOutMethodForConnect
|
* 连接超时
|
* @discussion The methods invoke to cancel the connection request Because connection attempts do not time out,
|
*
|
*/
|
-(void)timeOutMethodForConnect
|
{
|
isTimeOutAlert = YES;
|
[self cancelTimeOutAlert];
|
[self disconnectPeripheral:myPeripheral];
|
NSMutableDictionary *errorDetail = [NSMutableDictionary dictionary];
|
[errorDetail setValue:@"The Connection has Timed Out unexpectedly" forKey:NSLocalizedDescriptionKey];
|
NSError *error = [NSError errorWithDomain:@"myDomain" code:100 userInfo:errorDetail];
|
[self refreshPeripherals];
|
cbCommunicationHandler(NO,error);
|
}
|
|
/* Connection/Disconnection */
|
/****************************************************************************/
|
|
|
/*!
|
* @method connectPeripheral:CompletionBlock
|
*
|
* @param peripheral The peripheral to which the central is attempting to connect.
|
*
|
* @discussion Establishes a local connection to a peripheral.
|
*
|
*/
|
- (void) connectPeripheral:(CBPeripheral*)peripheral CompletionBlock:(void (^)(BOOL success, NSError *error))completionHandler
|
{
|
|
if((NSInteger)[centralManager state] == CBCentralManagerStatePoweredOn)
|
{
|
cbCommunicationHandler = completionHandler ;
|
|
if ([peripheral state] == CBPeripheralStateDisconnected)
|
{
|
[centralManager connectPeripheral:peripheral options:nil];
|
LOG_INFO(@"[%@] %@",peripheral.name,CONNECTION_REQUEST);
|
//[[LoggerHandler LogManager] LogData:[NSString stringWithFormat:@"[%@] %@",peripheral.name,CONNECTION_REQUEST]];
|
}
|
else
|
{
|
[centralManager cancelPeripheralConnection:peripheral];
|
}
|
|
[self performSelector:@selector(timeOutMethodForConnect) withObject:nil afterDelay:DEVICE_CONNECTION_TIMEOUT];
|
|
}
|
|
|
}
|
|
/*!
|
* @method disconnectPeripheral:
|
*
|
* @param peripheral The peripheral which needs to be disconnected from central.
|
*
|
* @discussion Cancels an active or pending local connection to a peripheral.
|
*
|
*/
|
|
- (void) disconnectPeripheral:(CBPeripheral*)peripheral
|
{
|
if(peripheral)
|
{
|
[centralManager cancelPeripheralConnection:peripheral];
|
}
|
}
|
|
- (void) centralManager:(CBCentralManager *)central didConnectPeripheral:(CBPeripheral *)peripheral
|
{
|
myPeripheral = nil;
|
myPeripheral = [peripheral copy];
|
myPeripheral.delegate = self ;
|
[myPeripheral discoverServices:nil];
|
|
LOG_INFO(@"[%@] %@",peripheral.name,CONNECTION_ESTABLISH);
|
LOG_INFO(@"[%@] %@",peripheral.name,SERVICE_DISCOVERY_REQUEST);
|
}
|
|
|
- (void) centralManager:(CBCentralManager *)central didFailToConnectPeripheral:(CBPeripheral *)peripheral error:(NSError *)error
|
{
|
NSLog(@"Attempted connection to peripheral %@ failed: %@", [peripheral name], [error localizedDescription]);
|
[self cancelTimeOutAlert];
|
cbCommunicationHandler(NO,error);
|
}
|
|
|
- (void) centralManager:(CBCentralManager *)central didDisconnectPeripheral:(CBPeripheral *)peripheral error:(NSError *)error
|
{
|
[self cancelTimeOutAlert];
|
|
/* Check whether the disconnection is done by the device */
|
if (error == nil && !isTimeOutAlert)
|
{
|
NSMutableDictionary *errorDetail = [NSMutableDictionary dictionary];
|
[errorDetail setValue:@"The BLE device is disconnected" forKey:NSLocalizedDescriptionKey];
|
NSError *disconnectError = [NSError errorWithDomain:@"myDomain" code:100 userInfo:errorDetail];
|
|
LOG_INFO(@"[%@] %@",peripheral.name,DISCONNECTION_REQUEST);
|
|
cbCommunicationHandler(NO,disconnectError);
|
}
|
else
|
{
|
isTimeOutAlert = NO;
|
|
// Checking whether the disconnected device has pending firmware upgrade
|
if ([[CBMoralManager sharedManager] bootLoaderFilesArray] != nil && error != nil)
|
{
|
NSMutableDictionary *errorDict = [NSMutableDictionary dictionary];
|
[errorDict setValue:[NSString stringWithFormat:@"%@%@",[error.userInfo objectForKey:NSLocalizedDescriptionKey],FIRMWARE_DISCONNECTION_ERROR] forKey:NSLocalizedDescriptionKey];
|
|
NSError *disconnectionError = [NSError errorWithDomain:@"myDomain" code:100 userInfo:errorDict];
|
cbCommunicationHandler(NO,disconnectionError);
|
}
|
else
|
cbCommunicationHandler(NO,error);
|
}
|
|
[self redirectToRootviewcontroller];
|
LOG_INFO(@"[%@] %@",peripheral.name,DISCONNECTED);
|
[self clearDevices];
|
}
|
|
/*!
|
* @method redirectToRootviewcontroller
|
*
|
* @discussion Pops all the view controllers on the stack except the root view controller and updates the display. This will redirect to BLE Devices Page which list all discovered peripherals,
|
*
|
*/
|
|
-(void)redirectToRootviewcontroller
|
{
|
if(cbDiscoveryDelegate)
|
{
|
[[(UIViewController*)cbDiscoveryDelegate navigationController] popToRootViewControllerAnimated:YES];
|
}
|
else if(cbCharacteristicDelegate)
|
{
|
[[(UIViewController*)cbCharacteristicDelegate navigationController] popToRootViewControllerAnimated:YES];
|
}
|
}
|
|
|
|
#pragma mark - Disc Services
|
|
/* Represents the current state of a CBCentralManager. */
|
/****************************************************************************/
|
|
|
|
// CBPeripheralDelegate - Invoked when you discover the peripheral's available services.
|
|
- (void)peripheral:(CBPeripheral *)peripheral didDiscoverServices:(NSError *)error
|
{
|
[self cancelTimeOutAlert];
|
if(error == nil)
|
{
|
LOG_INFO(@"[%@] %@- %@",peripheral.name,SERVICE_DISCOVERY_STATUS,SERVICE_DISCOVERED);
|
BOOL isCapsenseExist = NO;
|
for (CBService *service in peripheral.services)
|
{
|
|
if (![foundServices containsObject:service]) {
|
[foundServices addObject:service];
|
if([service.UUID isEqual:CAPSENSE_SERVICE_UUID])
|
{
|
isCapsenseExist = YES;
|
cbCharacteristicDelegate = nil;
|
[myPeripheral discoverCharacteristics:nil forService:service];
|
}
|
}
|
}
|
if(isCapsenseExist == NO )
|
cbCommunicationHandler(YES,nil);
|
}
|
else
|
{
|
LOG_INFO(@"[%@] %@- %@%@]",peripheral.name,SERVICE_DISCOVERY_STATUS,SERVICE_DISCOVERY_ERROR,[error.userInfo objectForKey:NSLocalizedDescriptionKey]);
|
|
cbCommunicationHandler(NO,error);
|
|
}
|
|
}
|
|
|
|
|
/* Represents the current state of a CBCentralManager. */
|
/****************************************************************************/
|
|
#pragma mark - characteristic/
|
|
- (void)peripheral:(CBPeripheral *)peripheral didDiscoverCharacteristicsForService:(CBService *)service error:(NSError *)error
|
{
|
|
if([cbCharacteristicDelegate isKindOfClass:[CBMoralManager class]] || cbCharacteristicDelegate == nil)
|
{
|
cbCommunicationHandler(YES,nil);
|
}
|
else
|
{
|
[cbCharacteristicDelegate peripheral:peripheral didDiscoverCharacteristicsForService:service error:error];
|
}
|
|
}
|
- (void)peripheral:(CBPeripheral *)peripheral didUpdateValueForCharacteristic:(CBCharacteristic *)characteristic error:(NSError *)error
|
{
|
if (error)
|
{
|
if (!characteristic.isNotifying)
|
{
|
[Utilities logDataWithService:[ResourceHandler getServiceNameForUUID:characteristic.service.UUID] characteristic:[ResourceHandler getCharacteristicNameForUUID:characteristic.UUID] descriptor:nil operation:[NSString stringWithFormat:@"%@- %@%@",READ_RESPONSE,READ_ERROR,[error.userInfo objectForKey:NSLocalizedDescriptionKey]]];
|
}
|
}
|
|
if([cbCharacteristicDelegate respondsToSelector:@selector(peripheral:didUpdateValueForCharacteristic:error:)])
|
[cbCharacteristicDelegate peripheral:peripheral didUpdateValueForCharacteristic:characteristic error:error];
|
}
|
|
- (void)peripheral:(CBPeripheral *)peripheral didWriteValueForCharacteristic:(CBCharacteristic *)characteristic error:(NSError *)error
|
{
|
if([cbCharacteristicDelegate respondsToSelector:@selector(peripheral:didWriteValueForCharacteristic:error:)])
|
[cbCharacteristicDelegate peripheral:peripheral didWriteValueForCharacteristic:characteristic error:error];
|
|
}
|
|
- (void)peripheral:(CBPeripheral *)peripheral didDiscoverDescriptorsForCharacteristic:(CBCharacteristic *)characteristic error:(NSError *)error
|
{
|
if([cbCharacteristicDelegate respondsToSelector:@selector(peripheral:didDiscoverDescriptorsForCharacteristic:error:)])
|
[cbCharacteristicDelegate peripheral:peripheral didDiscoverDescriptorsForCharacteristic:characteristic error:error];
|
}
|
|
-(void)peripheral:(CBPeripheral *)peripheral didUpdateValueForDescriptor:(CBDescriptor *)descriptor error:(NSError *)error
|
{
|
if (error)
|
{
|
[Utilities logDataWithService:[ResourceHandler getServiceNameForUUID:descriptor.characteristic.service.UUID] characteristic:[ResourceHandler getCharacteristicNameForUUID:descriptor.characteristic.UUID] descriptor:[Utilities getDiscriptorNameForUUID:descriptor.UUID] operation:[NSString stringWithFormat:@"%@- %@%@",READ_RESPONSE,READ_ERROR,[error.userInfo objectForKey:NSLocalizedDescriptionKey]]];
|
}
|
[cbCharacteristicDelegate peripheral:peripheral didUpdateValueForDescriptor:descriptor error:error];
|
}
|
|
|
#pragma mark - BLE State
|
|
/* Represents the current state of a CBCentralManager. */
|
/****************************************************************************/
|
|
/*!
|
* @method clearDevices
|
*
|
* @discussion Clear all listed peripherals and services,
|
*
|
*/
|
- (void) clearDevices
|
{
|
[peripheralListArray removeAllObjects];
|
[foundPeripherals removeAllObjects];
|
[foundServices removeAllObjects];
|
}
|
|
/*
|
Invoked when the central manager’s state is updated. (required)
|
|
If the state is On then app start scanning for peripherals that are advertising services.
|
If the state is Off then call method [clearDevices] and redirect to Home screen.
|
|
*/
|
|
|
- (void) centralManagerDidUpdateState:(CBCentralManager *)central
|
{
|
|
switch ((NSInteger)[centralManager state])
|
{
|
case CBCentralManagerStatePoweredOff:
|
{
|
[self clearDevices];
|
/* Tell user to power ON BT for functionality, but not on first run - the Framework will alert in that instance. */
|
//Show Alert
|
[self redirectToRootviewcontroller];
|
[cbDiscoveryDelegate bluetoothStateUpdatedToState:NO];
|
break;
|
}
|
|
case CBCentralManagerStateUnauthorized:
|
{
|
/* Tell user the app is not allowed. */
|
[Utilities alert:@"CySmart" Message:@"The app is not authorized to use bluetooth low energy"];
|
break;
|
}
|
|
case CBCentralManagerStateUnknown:
|
{
|
/* Bad news, let's wait for another event. */
|
[Utilities alert:@"CySmart" Message:@"The state of central manager is unknown."];
|
break;
|
}
|
|
case CBCentralManagerStatePoweredOn:
|
{
|
[cbDiscoveryDelegate bluetoothStateUpdatedToState:YES];
|
//暂时不需要马上检索
|
//[self startScanning];
|
break;
|
}
|
|
case CBCentralManagerStateResetting:
|
{
|
[self clearDevices];
|
break;
|
}
|
}
|
|
}
|
|
/*!
|
* @method refreshPeripherals
|
*
|
* @discussion Clear all listed peripherals and services.
|
Device scanning will add peripherals that are advertising services.
|
And check the status of Bluetooth and alert the user if Off,
|
*
|
*/
|
|
- (void) refreshPeripherals
|
{
|
[self clearDevices];
|
if([centralManager state] == CBCentralManagerStatePoweredOff)
|
{
|
[Utilities alert:WARNING Message:@"Turn On Bluetooth to Allow App to Connect to Accessories"];
|
}
|
// [[CBMoralManager sharedManager] stopScanning];
|
[[CBMoralManager sharedManager] startScanning];
|
}
|
|
|
|
|
@end
|
