SwiftyTeeth is a simple, lightweight library intended to take away some of the cruft and tediousness of using iOS BLE. It replaces CoreBluetooth's protocols and delegates with a callback-based pattern, and handles much of the code overhead associated with handling connections, discovery, reads/writes, and notifications. It is a spiritually similar library to Android's Blueteeth.
Both libraries were originally inspired by the simplicity and ease-of-use of LGBluetooth.
The motivation for this library was to provide an alternate (ideally - simpler) API than what iOS offers in CoreBluetooth to reduce complexity and code overhead. Another motivator was to provide an API that might make more sense 'practically' than CoreBluetooth's API, which exposes underlying implementation-specifics rather than abstracting them away.
For instance, with BLE devices, you connect to a peripheral, but in CoreBluetooth - you call connect on a manager singleton to connect to a peripheral, which makes sense for implementation-specifics (as there is only 1 Bluetooth radio which needs to manage all connections), but not semantically. In SwiftyTeeth, the 'Device' object has the connect method, the caller 'connects to a device', rather than the caller 'asks a singleton to connect to a device on it's behalf'.
Scan for BLE devices using SwiftyTeeth with a 1 second timeout:
SwiftyTeeth.shared.scan(for: 1) { devices in
self.devices = devices
self.tableView.reloadData()
}Alternatively, you could use the SwiftyTeethable protocol in an extension:
extension DeviceListViewController: SwiftyTeethable {
func scanTapped() {
swiftyTeeth.scan(for: 1) { devices in
self.devices = devices
self.tableView.reloadData()
}
}
}Initiate a connection using a SwiftyTeeth.Device:
device?.connect(complete: { isConnected in
print("Is device connected? \(isConnected == true)")
})Discover Bluetooth services and characteristics:
self.device?.discoverServices(complete: { services, error in
services.forEach({
print("Discovering characteristics for service: \($0.uuid.uuidString)")
self.device?.discoverCharacteristics(for: $0, complete: { service, characteristics, error in
characteristics.forEach({
print("App: Discovered characteristic: \($0.uuid.uuidString) in \(service.uuid.uuidString)")
})
if service == services.last {
print("App: All services/characteristics discovered")
}
})
})
})Write to a connected SwiftyTeeth.Device:
let command = Data(bytes: [0x01])
device?.write(data: command, to: characteristic, in: service, complete: { error in
print("Write with response successful? \(error == nil)")
})Read from a connected SwiftyTeeth.Device:
device?.read(from: characteristic, in: service, complete: { data, error in
print("Read value: \(data?.base64EncodedString())")
})Subscribe to notifications from a connected SwiftyTeeth.Device:
device?.subscribe(to: characteristic, in: service, complete: { data, error in
print("Subscribed value: \(data?.base64EncodedString())")
})Check out the sample app in SwiftyTeeth Sample/ to see the API in action.
Error handling in a BLE library is always tricky - but generally they should be fully asynchronous. In addition, having clear and concise error conditions, alongside seamless retries is crucial.
As mentioned in the Blueteeth post, Callback Hell (or rightward drift) sucks, but that hasn't yet been solved in this library. The current usage for chaining calls is still, unfortunately, callbacks in callbacks.
CoreBluetooth is also available on MacOS, so once completed and compiled correctly - there is no reason that it couldn't be used directly on a Mac, rather than only from iOS devices.
For the purposes of testing and debugging, being able to use a Mac as a demo-peripheral has immense value. CoreBluetooth supports central and peripheral modes of operation, so this would be a great (and useful) extension.
Now that this library is released and progressively becoming more stable, the next step in the process is to create Reactive bindings (RxSwift bindings specifically). They will be created in a separate repo, so that there isn't a forced, heavy dependency on the Rx framework in any app that just wants to use SwiftyTeeth.
Currently, you can use the master or develop branches and git directly until the API has stabilized.
platform :ios, '9.0'
use_frameworks!
pod 'SwiftyTeeth', :git => 'https://github.com/RobotPajamas/SwiftyTeeth.git', :branch => 'master'Instructions coming soon.
Please report all bugs or feature requests to: https://github.com/RobotPajamas/SwiftyTeeth/issues
Other iOS-centric Bluetooth libraries.
The Apache License (Apache)
Copyright (c) 2019 Robot Pajamas
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.