Scan for nearby devices

class MyApplication : Application() {
    override fun onCreate() {
        super.onCreate()
        AbleManager.shared.initalize(this)
    }
}

@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate {
    func application(_ application: UIApplication, 
                              didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        AbleManager.shared.initialize()
    }
}

Optionally, you can receive a callback, informing you if the AbleManager (and underlying iOS Bluetooth frameworks) are initialized:

AbleManager.shared.initialize() { status in
    switch status {
        case .success(_):
            print("AbleManager initialized!")
        case .failure(let error):
            print("AbleManager failed to initialize! Error: \(error.debugDescription)")
    }
}

The easiest way is, as always, to delegate that to AbleManager:

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        AbleManager.shared.handlePermissionRequestIfNotGranted(this)
    }
}

if AbleManager.shared.isAuthorized {
    // handle the case where permissions weren't granted
}

// If you're not in a Context, use BluetoothUtil.isOn(Context)
if (isBluetoothOn) {

}

// or
turnBluetoothOnIfOff()

iOS does not permit changing the Bluetooth state programatically, but you can still query if Bluetooth is on:

if AbleManager.shared.isBluetoothOn {
   // BLE is on, do your magic
}

Scanning is an async operation and there are three ways of going about it - coroutines, callback or the listener. Let's start with the callback approach - it scans for the given amount of time, and returns a Result<Set<AbleDevice>>:

AbleManager.shared.scan { result ->
        result.onSuccess { 
            // handle the devices set
        }.onFailure {
            // an exception has occurred
        }
}

The default timeout is 10 seconds, but you can specify it yourself:

AbleManager.shared.scan(30_000) { result ->
}

The coroutines approach is cleaner and avoids callback hell:

suspend fun scanForNearbyDevices() {
    try {
        val devices = AbleManager.scan()
    } catch (e: BluetoothStateException) {
        // handle the exception
    }
}

The listener is a more powerful callback, allowing you to have insight into all parts of the scanning process - when it starts and stops, when it discovers a new device and when it encounters an error.

AbleManager.shared.scan(object : AbleNearbyScanListener {
    override fun onStart() {
        // the scanning started
    }

    override fun onDeviceFound(device: AbleDevice) {
        // a single device was found, scanning continues
    }

    override fun onError(e: Exception) {
        // an error has occurred
    }

    override fun onStop() {
        // scanning stopped
    }
})

Exceptions in onError should only be of type BluetoothStateException.

If you need to stop an ongoing scan, use stopScan:

AbleManager.shared.stopScan()

Scanning is an async operation, so it requires using callbacks. Use scan to:

• scan for the given amount of time,
• stop scanning, and finally,
• return the accumulated set of AblePeripheralInfo, which contains the discovered AbleDevice, its RSSI and advertisment data.

AbleManager.shared.scan() { result in
    switch result {
    case .success(let infos):
        // get access to the set of peripheral infos
        let uniqueDevices = infos.devices
    case .failure(let error):
        // handle error
    }
}

The default timeout is 10 seconds, but you can specify it yourself:

AbleManager.shared.scan(for: 30.0) { infos in
}

Alternatively, you can use startScan to start scanning and report back when an AbleDevice is discovered, or an error has occurred:

AbleManager.shared.startScan() { result in
    switch result {
    case .success(let info):
        // get access to the device, its services, etc.
    case .failure(let error):
        // handle error
    }
}

Later, when you're done, stop scanning:

AbleManager.shared.stopScan()

Lastly, you can pass an array of service UUIDs to the scan call, in order to discover only devices supporting those services:

AbleManager.shared.startScan(with: [AbleUUID(string: "some-service-id"]) { result in
    switch result {
    case .success(let info):
        // get access to the device, its services, etc.
    case .failure(let error):
        // handle error
    }
}