/*

 File: LECentralViewController.m

 Abstract: Interface to use a CBCentralManager to scan for, and receive

 data from, a version of the app in Peripheral Mode

 Version: 1.0

 Disclaimer: IMPORTANT:  This Apple software is supplied to you by

 Apple Inc. ("Apple") in consideration of your agreement to the

 following terms, and your use, installation, modification or

 redistribution of this Apple software constitutes acceptance of these

 terms.  If you do not agree with these terms, please do not use,

 install, modify or redistribute this Apple software.

 In consideration of your agreement to abide by the following terms, and

 subject to these terms, Apple grants you a personal, non-exclusive

 license, under Apple's copyrights in this original Apple software (the

 "Apple Software"), to use, reproduce, modify and redistribute the Apple

 Software, with or without modifications, in source and/or binary forms;

 provided that if you redistribute the Apple Software in its entirety and

 without modifications, you must retain this notice and the following

 text and disclaimers in all such redistributions of the Apple Software.

 Neither the name, trademarks, service marks or logos of Apple Inc.

 may be used to endorse or promote products derived from the Apple

 Software without specific prior written permission from Apple.  Except

 as expressly stated in this notice, no other rights or licenses, express

 or implied, are granted by Apple herein, including but not limited to

 any patent rights that may be infringed by your derivative works or by

 other works in which the Apple Software may be incorporated.

 The Apple Software is provided by Apple on an "AS IS" basis.  APPLE

 MAKES NO WARRANTIES, EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION

 THE IMPLIED WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY AND FITNESS

 FOR A PARTICULAR PURPOSE, REGARDING THE APPLE SOFTWARE OR ITS USE AND

 OPERATION ALONE OR IN COMBINATION WITH YOUR PRODUCTS.

 IN NO EVENT SHALL APPLE BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL

 OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

 INTERRUPTION) ARISING IN ANY WAY OUT OF THE USE, REPRODUCTION,

 MODIFICATION AND/OR DISTRIBUTION OF THE APPLE SOFTWARE, HOWEVER CAUSED

 AND WHETHER UNDER THEORY OF CONTRACT, TORT (INCLUDING NEGLIGENCE),

 STRICT LIABILITY OR OTHERWISE, EVEN IF APPLE HAS BEEN ADVISED OF THE

 POSSIBILITY OF SUCH DAMAGE.

 Copyright (C) 2012 Apple Inc. All Rights Reserved.

 */

#import "BTLECentralViewController.h"

#import <CoreBluetooth/CoreBluetooth.h>

#import "TransferService.h"

@interface BTLECentralViewController () <CBCentralManagerDelegate, CBPeripheralDelegate>

@property (strong, nonatomic) IBOutlet UITextView   *textview;

@property (strong, nonatomic) CBCentralManager      *centralManager;

@property (strong, nonatomic) CBPeripheral          *discoveredPeripheral;

@property (strong, nonatomic) NSMutableData         *data;

@end

@implementation BTLECentralViewController

#pragma mark - View Lifecycle

- (void)viewDidLoad

{

    [super viewDidLoad];

    // Start up the CBCentralManager

    _centralManager = [[CBCentralManager alloc] initWithDelegate:self queue:nil];

    // And somewhere to store the incoming data

    _data = [[NSMutableData alloc] init];

}

- (void)viewWillDisappear:(BOOL)animated

{

    // Don't keep it going while we're not showing.

    [self.centralManager stopScan];

    NSLog(@"Scanning stopped");

    [super viewWillDisappear:animated];

}

#pragma mark - Central Methods

/** centralManagerDidUpdateState is a required protocol method.

 *  Usually, you'd check for other states to make sure the current device supports LE, is powered on, etc.

 *  In this instance, we're just using it to wait for CBCentralManagerStatePoweredOn, which indicates

 *  the Central is ready to be used.

 */

- (void)centralManagerDidUpdateState:(CBCentralManager *)central

{

    if (central.state != CBCentralManagerStatePoweredOn) {

        // In a real app, you'd deal with all the states correctly

        return;

    }

    // The state must be CBCentralManagerStatePoweredOn...

    // ... so start scanning

    [self scan];

}

/** Scan for peripherals - specifically for our service's 128bit CBUUID

 */

- (void)scan

{

    [self.centralManager scanForPeripheralsWithServices:@[[CBUUID UUIDWithString:TRANSFER_SERVICE_UUID]]

                                                options:@{ CBCentralManagerScanOptionAllowDuplicatesKey : @YES }];

    NSLog(@"Scanning started");

}

/** This callback comes whenever a peripheral that is advertising the TRANSFER_SERVICE_UUID is discovered.

 *  We check the RSSI, to make sure it's close enough that we're interested in it, and if it is, 

 *  we start the connection process

 */

- (void)centralManager:(CBCentralManager *)central didDiscoverPeripheral:(CBPeripheral *)peripheral advertisementData:(NSDictionary *)advertisementData RSSI:(NSNumber *)RSSI

{

    // Reject any where the value is above reasonable range

    if (RSSI.integerValue > -15) {

        return;

    }

    // Reject if the signal strength is too low to be close enough (Close is around -22dB)

    if (RSSI.integerValue < -35) {

        return;

    }

    NSLog(@"Discovered %@ at %@", peripheral.name, RSSI);

    // Ok, it's in range - have we already seen it?

    if (self.discoveredPeripheral != peripheral) {

        // Save a local copy of the peripheral, so CoreBluetooth doesn't get rid of it

        self.discoveredPeripheral = peripheral;

        // And connect

        NSLog(@"Connecting to peripheral %@", peripheral);

        [self.centralManager connectPeripheral:peripheral options:nil];

    }

}

/** If the connection fails for whatever reason, we need to deal with it.

 */

- (void)centralManager:(CBCentralManager *)central didFailToConnectPeripheral:(CBPeripheral *)peripheral error:(NSError *)error

{

    NSLog(@"Failed to connect to %@. (%@)", peripheral, [error localizedDescription]);

    [self cleanup];

}

/** We've connected to the peripheral, now we need to discover the services and characteristics to find the 'transfer' characteristic.

 */

- (void)centralManager:(CBCentralManager *)central didConnectPeripheral:(CBPeripheral *)peripheral

{

    NSLog(@"Peripheral Connected");

    // Stop scanning

    [self.centralManager stopScan];

    NSLog(@"Scanning stopped");

    // Clear the data that we may already have

    [self.data setLength:0];

    // Make sure we get the discovery callbacks

    peripheral.delegate = self;

    // Search only for services that match our UUID

    [peripheral discoverServices:@[[CBUUID UUIDWithString:TRANSFER_SERVICE_UUID]]];

}

/** The Transfer Service was discovered

 */

- (void)peripheral:(CBPeripheral *)peripheral didDiscoverServices:(NSError *)error

{

    if (error) {

        NSLog(@"Error discovering services: %@", [error localizedDescription]);

        [self cleanup];

        return;

    }

    // Discover the characteristic we want...

    // Loop through the newly filled peripheral.services array, just in case there's more than one.

    for (CBService *service in peripheral.services) {

        [peripheral discoverCharacteristics:@[[CBUUID UUIDWithString:TRANSFER_CHARACTERISTIC_UUID]] forService:service];

    }

}

/** The Transfer characteristic was discovered.

 *  Once this has been found, we want to subscribe to it, which lets the peripheral know we want the data it contains

 */

- (void)peripheral:(CBPeripheral *)peripheral didDiscoverCharacteristicsForService:(CBService *)service error:(NSError *)error

{

    // Deal with errors (if any)

    if (error) {

        NSLog(@"Error discovering characteristics: %@", [error localizedDescription]);

        [self cleanup];

        return;

    }

    // Again, we loop through the array, just in case.

    for (CBCharacteristic *characteristic in service.characteristics) {

        // And check if it's the right one

        if ([characteristic.UUID isEqual:[CBUUID UUIDWithString:TRANSFER_CHARACTERISTIC_UUID]]) {

            // If it is, subscribe to it

            [peripheral setNotifyValue:YES forCharacteristic:characteristic];

        }

    }

    // Once this is complete, we just need to wait for the data to come in.

}

/** This callback lets us know more data has arrived via notification on the characteristic

 */

- (void)peripheral:(CBPeripheral *)peripheral didUpdateValueForCharacteristic:(CBCharacteristic *)characteristic error:(NSError *)error

{

    if (error) {

        NSLog(@"Error discovering characteristics: %@", [error localizedDescription]);

        return;

    }

    NSString *stringFromData = [[NSString alloc] initWithData:characteristic.value encoding:NSUTF8StringEncoding];

    // Have we got everything we need?

    if ([stringFromData isEqualToString:@"EOM"]) {

        // We have, so show the data, 

        [self.textview setText:[[NSString alloc] initWithData:self.data encoding:NSUTF8StringEncoding]];

        // Cancel our subscription to the characteristic

        [peripheral setNotifyValue:NO forCharacteristic:characteristic];

        // and disconnect from the peripehral

        [self.centralManager cancelPeripheralConnection:peripheral];

    }

    // Otherwise, just add the data on to what we already have

    [self.data appendData:characteristic.value];

    // Log it

    NSLog(@"Received: %@", stringFromData);

}

/** The peripheral letting us know whether our subscribe/unsubscribe happened or not

 */

- (void)peripheral:(CBPeripheral *)peripheral didUpdateNotificationStateForCharacteristic:(CBCharacteristic *)characteristic error:(NSError *)error

{

    if (error) {

        NSLog(@"Error changing notification state: %@", error.localizedDescription);

    }

    // Exit if it's not the transfer characteristic

    if (![characteristic.UUID isEqual:[CBUUID UUIDWithString:TRANSFER_CHARACTERISTIC_UUID]]) {

        return;

    }

    // Notification has started

    if (characteristic.isNotifying) {

        NSLog(@"Notification began on %@", characteristic);

    }

    // Notification has stopped

    else {

        // so disconnect from the peripheral

        NSLog(@"Notification stopped on %@.  Disconnecting", characteristic);

        [self.centralManager cancelPeripheralConnection:peripheral];

    }

}

/** Once the disconnection happens, we need to clean up our local copy of the peripheral

 */

- (void)centralManager:(CBCentralManager *)central didDisconnectPeripheral:(CBPeripheral *)peripheral error:(NSError *)error

{

    NSLog(@"Peripheral Disconnected");

    self.discoveredPeripheral = nil;

    // We're disconnected, so start scanning again

    [self scan];

}

/** Call this when things either go wrong, or you're done with the connection.

 *  This cancels any subscriptions if there are any, or straight disconnects if not.

 *  (didUpdateNotificationStateForCharacteristic will cancel the connection if a subscription is involved)

 */

- (void)cleanup

{

    // Don't do anything if we're not connected

    if (!self.discoveredPeripheral.isConnected) {

        return;

    }

    // See if we are subscribed to a characteristic on the peripheral

    if (self.discoveredPeripheral.services != nil) {

        for (CBService *service in self.discoveredPeripheral.services) {

            if (service.characteristics != nil) {

                for (CBCharacteristic *characteristic in service.characteristics) {

                    if ([characteristic.UUID isEqual:[CBUUID UUIDWithString:TRANSFER_CHARACTERISTIC_UUID]]) {

                        if (characteristic.isNotifying) {

                            // It is notifying, so unsubscribe

                            [self.discoveredPeripheral setNotifyValue:NO forCharacteristic:characteristic];

                            // And we're done.

                            return;

                        }

                    }

                }

            }

        }

    }

    // If we've got this far, we're connected, but we're not subscribed, so we just disconnect

    [self.centralManager cancelPeripheralConnection:self.discoveredPeripheral];

}

@end