mirror of
https://github.com/meshtastic/Meshtastic-Android.git
synced 2026-04-20 22:23:37 +00:00
762 lines
30 KiB
Kotlin
762 lines
30 KiB
Kotlin
package com.geeksville.mesh.service
|
|
|
|
import android.bluetooth.*
|
|
import android.content.BroadcastReceiver
|
|
import android.content.Context
|
|
import android.content.Intent
|
|
import android.content.IntentFilter
|
|
import android.os.Build
|
|
import android.os.Handler
|
|
import com.geeksville.android.GeeksvilleApplication
|
|
import com.geeksville.android.Logging
|
|
import com.geeksville.concurrent.CallbackContinuation
|
|
import com.geeksville.concurrent.Continuation
|
|
import com.geeksville.concurrent.SyncContinuation
|
|
import com.geeksville.util.exceptionReporter
|
|
import com.geeksville.util.ignoreException
|
|
import kotlinx.coroutines.*
|
|
import java.io.Closeable
|
|
import java.util.*
|
|
|
|
|
|
/// Return a standard BLE 128 bit UUID from the short 16 bit versions
|
|
fun longBLEUUID(hexFour: String) = UUID.fromString("0000$hexFour-0000-1000-8000-00805f9b34fb")
|
|
|
|
|
|
/**
|
|
* A helper class to call onChanged when bluetooth is enabled or disabled
|
|
*/
|
|
class BluetoothStateReceiver(val onChanged: (Boolean) -> Unit) : BroadcastReceiver() {
|
|
val intent = IntentFilter(BluetoothAdapter.ACTION_STATE_CHANGED) // Can be used for registering
|
|
|
|
override fun onReceive(context: Context, intent: Intent) = exceptionReporter {
|
|
if (intent.action == BluetoothAdapter.ACTION_STATE_CHANGED) {
|
|
when (intent.getIntExtra(BluetoothAdapter.EXTRA_STATE, -1)) {
|
|
// Simulate a disconnection if the user disables bluetooth entirely
|
|
BluetoothAdapter.STATE_OFF -> onChanged(false)
|
|
BluetoothAdapter.STATE_ON -> onChanged(true)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Uses coroutines to safely access a bluetooth GATT device with a synchronous API
|
|
*
|
|
* The BTLE API on android is dumb. You can only have one outstanding operation in flight to
|
|
* the device. If you try to do something when something is pending, the operation just returns
|
|
* false. You are expected to chain your operations from the results callbacks.
|
|
*
|
|
* This class fixes the API by using coroutines to let you safely do a series of BTLE operations.
|
|
*/
|
|
class SafeBluetooth(private val context: Context, private val device: BluetoothDevice) :
|
|
Logging, Closeable {
|
|
|
|
/// Timeout before we declare a bluetooth operation failed
|
|
var timeoutMsec = 15 * 1000L
|
|
|
|
/// Users can access the GATT directly as needed
|
|
var gatt: BluetoothGatt? = null
|
|
|
|
@Volatile
|
|
var state = BluetoothProfile.STATE_DISCONNECTED
|
|
|
|
@Volatile
|
|
private var currentWork: BluetoothContinuation? = null
|
|
private val workQueue = mutableListOf<BluetoothContinuation>()
|
|
|
|
// Called for reconnection attemps
|
|
@Volatile
|
|
private var connectionCallback: ((Result<Unit>) -> Unit)? = null
|
|
|
|
@Volatile
|
|
private var lostConnectCallback: (() -> Unit)? = null
|
|
|
|
/// from characteristic UUIDs to the handler function for notfies
|
|
private val notifyHandlers = mutableMapOf<UUID, (BluetoothGattCharacteristic) -> Unit>()
|
|
|
|
private val serviceScope = CoroutineScope(Dispatchers.IO)
|
|
|
|
/// When we see the BT stack getting disabled/renabled we handle that as a connect/disconnect event
|
|
private val btStateReceiver = BluetoothStateReceiver { enabled ->
|
|
// Sometimes we might not have a gatt object, while that is true, we don't care about BLE state changes
|
|
gatt?.let { g ->
|
|
if (!enabled) {
|
|
if (state == BluetoothProfile.STATE_CONNECTED)
|
|
gattCallback.onConnectionStateChange(
|
|
g,
|
|
0,
|
|
BluetoothProfile.STATE_DISCONNECTED
|
|
)
|
|
else
|
|
debug("We were not connected, so ignoring bluetooth shutdown")
|
|
} else {
|
|
warn("requeue a connect anytime bluetooth is reenabled")
|
|
reconnect()
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* A BLE status code based error
|
|
*/
|
|
class BLEStatusException(val status: Int, msg: String) : BLEException(msg)
|
|
|
|
// 0x2902 org.bluetooth.descriptor.gatt.client_characteristic_configuration.xml
|
|
private val configurationDescriptorUUID =
|
|
longBLEUUID("2902")
|
|
|
|
init {
|
|
context.registerReceiver(
|
|
btStateReceiver,
|
|
btStateReceiver.intent
|
|
)
|
|
}
|
|
|
|
/**
|
|
* a schedulable bit of bluetooth work, includes both the closure to call to start the operation
|
|
* and the completion (either async or sync) to call when it completes
|
|
*/
|
|
private class BluetoothContinuation(
|
|
val tag: String,
|
|
val completion: com.geeksville.concurrent.Continuation<*>,
|
|
val timeoutMillis: Long = 0, // If we want to timeout this operation at a certain time, use a non zero value
|
|
private val startWorkFn: () -> Boolean
|
|
) : Logging {
|
|
|
|
/// Start running a queued bit of work, return true for success or false for fatal bluetooth error
|
|
fun startWork(): Boolean {
|
|
debug("Starting work: $tag")
|
|
return startWorkFn()
|
|
}
|
|
|
|
override fun toString(): String {
|
|
return super.toString()
|
|
}
|
|
}
|
|
|
|
/**
|
|
* skanky hack to restart BLE if it says it is hosed
|
|
* https://stackoverflow.com/questions/35103701/ble-android-onconnectionstatechange-not-being-called
|
|
*/
|
|
private val mHandler: Handler = Handler()
|
|
|
|
fun restartBle() {
|
|
GeeksvilleApplication.analytics.track("ble_restart") // record # of times we needed to use this nasty hack
|
|
errormsg("Doing emergency BLE restart")
|
|
val mgr =
|
|
context.getSystemService(Context.BLUETOOTH_SERVICE) as BluetoothManager
|
|
val adp = mgr.adapter
|
|
if (null != adp) {
|
|
if (adp.isEnabled) {
|
|
adp.disable()
|
|
// TODO: display some kind of UI about restarting BLE
|
|
mHandler.postDelayed(object : Runnable {
|
|
override fun run() {
|
|
if (!adp.isEnabled) {
|
|
adp.enable()
|
|
} else {
|
|
mHandler.postDelayed(this, 2500)
|
|
}
|
|
}
|
|
}, 2500)
|
|
}
|
|
}
|
|
}
|
|
|
|
// Our own custom BLE status codes
|
|
private val STATUS_RELIABLE_WRITE_FAILED = 4403
|
|
private val STATUS_TIMEOUT = 4404
|
|
|
|
private val gattCallback = object : BluetoothGattCallback() {
|
|
|
|
override fun onConnectionStateChange(
|
|
g: BluetoothGatt,
|
|
status: Int,
|
|
newState: Int
|
|
) = exceptionReporter {
|
|
info("new bluetooth connection state $newState, status $status")
|
|
|
|
when (newState) {
|
|
BluetoothProfile.STATE_CONNECTED -> {
|
|
state =
|
|
newState // we only care about connected/disconnected - not the transitional states
|
|
|
|
// If autoconnect is on and this connect attempt failed, hopefully some future attempt will succeed
|
|
if (status != BluetoothGatt.GATT_SUCCESS && autoConnect) {
|
|
errormsg("Connect attempt failed $status, not calling connect completion handler...")
|
|
} else
|
|
completeWork(status, Unit)
|
|
}
|
|
BluetoothProfile.STATE_DISCONNECTED -> {
|
|
if (gatt == null)
|
|
info("No gatt: ignoring connection state $newState, status $status") // Probably just shutting down
|
|
else {
|
|
// cancel any queued ops if we were already connected
|
|
val oldstate = state
|
|
state = newState
|
|
if (oldstate == BluetoothProfile.STATE_CONNECTED) {
|
|
info("Lost connection - aborting current work: $currentWork")
|
|
|
|
/*
|
|
Supposedly this reconnect attempt happens automatically
|
|
"If the connection was established through an auto connect, Android will
|
|
automatically try to reconnect to the remote device when it gets disconnected
|
|
until you manually call disconnect() or close(). Once a connection established
|
|
through direct connect disconnects, no attempt is made to reconnect to the remote device."
|
|
https://stackoverflow.com/questions/37965337/what-exactly-does-androids-bluetooth-autoconnect-parameter-do?rq=1
|
|
|
|
closeConnection()
|
|
*/
|
|
failAllWork(BLEException("Lost connection"))
|
|
|
|
// Cancel any notifications - because when the device comes back it might have forgotten about us
|
|
notifyHandlers.clear()
|
|
|
|
lostConnectCallback?.let {
|
|
debug("calling lostConnect handler")
|
|
it.invoke()
|
|
}
|
|
|
|
// Queue a new connection attempt
|
|
val cb = connectionCallback
|
|
if (cb != null) {
|
|
debug("queuing a reconnection callback")
|
|
assert(currentWork == null)
|
|
|
|
if (!currentConnectIsAuto) { // we must have been running during that 1-time manual connect, switch to auto-mode from now on
|
|
closeGatt() // Close the old non-auto connection
|
|
lowLevelConnect(true)
|
|
}
|
|
|
|
// note - we don't need an init fn (because that would normally redo the connectGatt call - which we don't need)
|
|
queueWork("reconnect", CallbackContinuation(cb)) { -> true }
|
|
} else {
|
|
debug("No connectionCallback registered")
|
|
}
|
|
} else if (status == 133) {
|
|
// We were not previously connected and we just failed with our non-auto connection attempt. Therefore we now need
|
|
// to do an autoconnection attempt. When that attempt succeeds/fails the normal callbacks will be called
|
|
|
|
// Note: To workaround https://issuetracker.google.com/issues/36995652
|
|
// Always call BluetoothDevice#connectGatt() with autoConnect=false
|
|
// (the race condition does not affect that case). If that connection times out
|
|
// you will get a callback with status=133. Then call BluetoothGatt#connect()
|
|
// to initiate a background connection.
|
|
if (autoConnect) {
|
|
warn("Failed on non-auto connect, falling back to auto connect attempt")
|
|
closeGatt() // Close the old non-auto connection
|
|
lowLevelConnect(true)
|
|
}
|
|
}
|
|
|
|
if (status == 257) { // mystery error code when phone is hung
|
|
//throw Exception("Mystery bluetooth failure - debug me")
|
|
restartBle()
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
override fun onServicesDiscovered(gatt: BluetoothGatt, status: Int) {
|
|
// For testing lie and claim failure
|
|
completeWork(status, Unit)
|
|
}
|
|
|
|
override fun onCharacteristicRead(
|
|
gatt: BluetoothGatt,
|
|
characteristic: BluetoothGattCharacteristic,
|
|
status: Int
|
|
) {
|
|
completeWork(status, characteristic)
|
|
}
|
|
|
|
override fun onReliableWriteCompleted(gatt: BluetoothGatt, status: Int) {
|
|
completeWork(status, Unit)
|
|
}
|
|
|
|
override fun onCharacteristicWrite(
|
|
gatt: BluetoothGatt,
|
|
characteristic: BluetoothGattCharacteristic,
|
|
status: Int
|
|
) {
|
|
val reliable = currentReliableWrite
|
|
if (reliable != null)
|
|
if (!characteristic.value.contentEquals(reliable)) {
|
|
errormsg("A reliable write failed!")
|
|
gatt.abortReliableWrite();
|
|
completeWork(
|
|
STATUS_RELIABLE_WRITE_FAILED,
|
|
characteristic
|
|
) // skanky code to indicate failure
|
|
} else {
|
|
logAssert(gatt.executeReliableWrite())
|
|
// After this execute reliable completes - we can continue with normal operations (see onReliableWriteCompleted)
|
|
}
|
|
else // Just a standard write - do the normal flow
|
|
completeWork(status, characteristic)
|
|
}
|
|
|
|
override fun onMtuChanged(gatt: BluetoothGatt, mtu: Int, status: Int) {
|
|
// Alas, passing back an Int mtu isn't working and since I don't really care what MTU
|
|
// the device was willing to let us have I'm just punting and returning Unit
|
|
if (isSettingMtu)
|
|
completeWork(status, Unit)
|
|
else
|
|
errormsg("Ignoring bogus onMtuChanged")
|
|
}
|
|
|
|
/**
|
|
* Callback triggered as a result of a remote characteristic notification.
|
|
*
|
|
* @param gatt GATT client the characteristic is associated with
|
|
* @param characteristic Characteristic that has been updated as a result of a remote
|
|
* notification event.
|
|
*/
|
|
override fun onCharacteristicChanged(
|
|
gatt: BluetoothGatt,
|
|
characteristic: BluetoothGattCharacteristic
|
|
) {
|
|
val handler = notifyHandlers.get(characteristic.uuid)
|
|
if (handler == null)
|
|
warn("Received notification from $characteristic, but no handler registered")
|
|
else {
|
|
exceptionReporter {
|
|
handler(characteristic)
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Callback indicating the result of a descriptor write operation.
|
|
*
|
|
* @param gatt GATT client invoked [BluetoothGatt.writeDescriptor]
|
|
* @param descriptor Descriptor that was writte to the associated remote device.
|
|
* @param status The result of the write operation [BluetoothGatt.GATT_SUCCESS] if the
|
|
* operation succeeds.
|
|
*/
|
|
override fun onDescriptorWrite(
|
|
gatt: BluetoothGatt,
|
|
descriptor: BluetoothGattDescriptor,
|
|
status: Int
|
|
) {
|
|
completeWork(status, descriptor)
|
|
}
|
|
|
|
/**
|
|
* Callback reporting the result of a descriptor read operation.
|
|
*
|
|
* @param gatt GATT client invoked [BluetoothGatt.readDescriptor]
|
|
* @param descriptor Descriptor that was read from the associated remote device.
|
|
* @param status [BluetoothGatt.GATT_SUCCESS] if the read operation was completed
|
|
* successfully
|
|
*/
|
|
override fun onDescriptorRead(
|
|
gatt: BluetoothGatt,
|
|
descriptor: BluetoothGattDescriptor,
|
|
status: Int
|
|
) {
|
|
completeWork(status, descriptor)
|
|
}
|
|
}
|
|
|
|
|
|
private var activeTimeout: Job? = null
|
|
|
|
/// If we have work we can do, start doing it.
|
|
private fun startNewWork() {
|
|
logAssert(currentWork == null)
|
|
|
|
if (workQueue.isNotEmpty()) {
|
|
val newWork = workQueue.removeAt(0)
|
|
currentWork = newWork
|
|
|
|
if (newWork.timeoutMillis != 0L) {
|
|
|
|
activeTimeout = serviceScope.launch {
|
|
debug("Starting failsafe timer ${newWork.timeoutMillis}")
|
|
delay(newWork.timeoutMillis)
|
|
errormsg("Failsafe BLE timer expired!")
|
|
completeWork(
|
|
STATUS_TIMEOUT,
|
|
Unit
|
|
) // Throw an exception in that work
|
|
}
|
|
}
|
|
|
|
isSettingMtu =
|
|
false // Most work is not doing MTU stuff, the work that is will re set this flag
|
|
logAssert(newWork.startWork())
|
|
}
|
|
}
|
|
|
|
private fun <T> queueWork(
|
|
tag: String,
|
|
cont: Continuation<T>,
|
|
timeout: Long = 0,
|
|
initFn: () -> Boolean
|
|
) {
|
|
val btCont =
|
|
BluetoothContinuation(
|
|
tag,
|
|
cont,
|
|
timeout,
|
|
initFn
|
|
)
|
|
|
|
synchronized(workQueue) {
|
|
debug("Enqueuing work: ${btCont.tag}")
|
|
workQueue.add(btCont)
|
|
|
|
// if we don't have any outstanding operations, run first item in queue
|
|
if (currentWork == null)
|
|
startNewWork()
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Stop any current work
|
|
*/
|
|
private fun stopCurrentWork() {
|
|
activeTimeout?.let {
|
|
it.cancel()
|
|
activeTimeout = null
|
|
}
|
|
currentWork = null
|
|
}
|
|
|
|
/**
|
|
* Called from our big GATT callback, completes the current job and then schedules a new one
|
|
*/
|
|
private fun <T : Any> completeWork(status: Int, res: T) {
|
|
exceptionReporter {
|
|
// We might unexpectedly fail inside here, but we don't want to pass that exception back up to the bluetooth GATT layer
|
|
|
|
// startup next job in queue before calling the completion handler
|
|
val work =
|
|
synchronized(workQueue) {
|
|
val w =
|
|
currentWork
|
|
?: throw Exception("currentWork was null") // will throw if null, which is helpful (FIXME - throws in the field - because of a bogus mtu completion gatt call)
|
|
stopCurrentWork() // We are now no longer working on anything
|
|
|
|
startNewWork()
|
|
w
|
|
}
|
|
|
|
debug("work ${work.tag} is completed, resuming status=$status, res=$res")
|
|
if (status != 0)
|
|
work.completion.resumeWithException(
|
|
BLEStatusException(
|
|
status,
|
|
"Bluetooth status=$status while doing ${work.tag}"
|
|
)
|
|
)
|
|
else
|
|
work.completion.resume(Result.success(res) as Result<Nothing>)
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Something went wrong, abort all queued
|
|
*/
|
|
private fun failAllWork(ex: Exception) {
|
|
synchronized(workQueue) {
|
|
workQueue.forEach {
|
|
it.completion.resumeWithException(ex)
|
|
}
|
|
workQueue.clear()
|
|
stopCurrentWork()
|
|
}
|
|
}
|
|
|
|
/// helper glue to make sync continuations and then wait for the result
|
|
private fun <T> makeSync(wrappedFn: (SyncContinuation<T>) -> Unit): T {
|
|
val cont = SyncContinuation<T>()
|
|
wrappedFn(cont)
|
|
return cont.await(timeoutMsec)
|
|
}
|
|
|
|
// Is the gatt trying to repeatedly connect as needed?
|
|
private var autoConnect = false
|
|
|
|
/// True if the current active connection is auto (possible for this to be false but autoConnect to be true
|
|
/// if we are in the first non-automated lowLevel connect.
|
|
private var currentConnectIsAuto = false
|
|
|
|
private fun lowLevelConnect(autoNow: Boolean): BluetoothGatt? {
|
|
currentConnectIsAuto = autoNow
|
|
logAssert(gatt == null)
|
|
|
|
val g = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
|
|
device.connectGatt(
|
|
context,
|
|
autoNow,
|
|
gattCallback,
|
|
BluetoothDevice.TRANSPORT_LE
|
|
)
|
|
} else {
|
|
device.connectGatt(
|
|
context,
|
|
autoNow,
|
|
gattCallback
|
|
)
|
|
}
|
|
|
|
gatt = g
|
|
return g
|
|
}
|
|
|
|
// FIXME, pass in true for autoconnect - so we will autoconnect whenever the radio
|
|
// comes in range (even if we made this connect call long ago when we got powered on)
|
|
// see https://stackoverflow.com/questions/40156699/which-correct-flag-of-autoconnect-in-connectgatt-of-ble for
|
|
// more info.
|
|
// Otherwise if you pass in false, it will try to connect now and will timeout and fail in 30 seconds.
|
|
private fun queueConnect(
|
|
autoConnect: Boolean = false,
|
|
cont: Continuation<Unit>
|
|
) {
|
|
this.autoConnect = autoConnect
|
|
|
|
// assert(gatt == null) this now might be !null with our new reconnect support
|
|
queueWork("connect", cont) {
|
|
|
|
// Note: To workaround https://issuetracker.google.com/issues/36995652
|
|
// Always call BluetoothDevice#connectGatt() with autoConnect=false
|
|
// (the race condition does not affect that case). If that connection times out
|
|
// you will get a callback with status=133. Then call BluetoothGatt#connect()
|
|
// to initiate a background connection.
|
|
val g = lowLevelConnect(false)
|
|
g != null
|
|
}
|
|
}
|
|
|
|
/**
|
|
* start a connection attempt.
|
|
*
|
|
* Note: if autoConnect is true, the callback you provide will be kept around _even after the connection is complete.
|
|
* If we ever lose the connection, this class will immediately requque the attempt (after canceling
|
|
* any outstanding queued operations).
|
|
*
|
|
* So you should expect your callback might be called multiple times, each time to reestablish a new connection.
|
|
*/
|
|
fun asyncConnect(
|
|
autoConnect: Boolean = false,
|
|
cb: (Result<Unit>) -> Unit,
|
|
lostConnectCb: () -> Unit
|
|
) {
|
|
logAssert(workQueue.isEmpty())
|
|
if (currentWork != null)
|
|
throw AssertionError("currentWork was not null: $currentWork")
|
|
|
|
lostConnectCallback = lostConnectCb
|
|
connectionCallback = if (autoConnect)
|
|
cb
|
|
else
|
|
null
|
|
queueConnect(autoConnect, CallbackContinuation(cb))
|
|
}
|
|
|
|
/// Restart any previous connect attempts
|
|
private fun reconnect() {
|
|
connectionCallback?.let { cb ->
|
|
queueConnect(true, CallbackContinuation(cb))
|
|
}
|
|
}
|
|
|
|
fun connect(autoConnect: Boolean = false) =
|
|
makeSync<Unit> { queueConnect(autoConnect, it) }
|
|
|
|
private fun queueReadCharacteristic(
|
|
c: BluetoothGattCharacteristic,
|
|
cont: Continuation<BluetoothGattCharacteristic>
|
|
) = queueWork("readC ${c.uuid}", cont) { gatt!!.readCharacteristic(c) }
|
|
|
|
fun asyncReadCharacteristic(
|
|
c: BluetoothGattCharacteristic,
|
|
cb: (Result<BluetoothGattCharacteristic>) -> Unit
|
|
) = queueReadCharacteristic(c, CallbackContinuation(cb))
|
|
|
|
fun readCharacteristic(c: BluetoothGattCharacteristic): BluetoothGattCharacteristic =
|
|
makeSync { queueReadCharacteristic(c, it) }
|
|
|
|
private fun queueDiscoverServices(cont: Continuation<Unit>) {
|
|
queueWork("discover", cont) {
|
|
gatt!!.discoverServices()
|
|
}
|
|
}
|
|
|
|
fun asyncDiscoverServices(cb: (Result<Unit>) -> Unit) {
|
|
queueDiscoverServices(CallbackContinuation(cb))
|
|
}
|
|
|
|
fun discoverServices() = makeSync<Unit> { queueDiscoverServices(it) }
|
|
|
|
/**
|
|
* On some phones we receive bogus mtu gatt callbacks, we need to ignore them if we weren't setting the mtu
|
|
*/
|
|
private var isSettingMtu = false
|
|
|
|
/**
|
|
* mtu operations seem to hang sometimes. To cope with this we have a 5 second timeout before throwing an exception and cancelling the work
|
|
*/
|
|
private fun queueRequestMtu(
|
|
len: Int,
|
|
cont: Continuation<Unit>
|
|
) = queueWork("reqMtu", cont, 5 * 1000) {
|
|
isSettingMtu = true
|
|
gatt!!.requestMtu(len)
|
|
}
|
|
|
|
fun asyncRequestMtu(
|
|
len: Int,
|
|
cb: (Result<Unit>) -> Unit
|
|
) {
|
|
queueRequestMtu(len, CallbackContinuation(cb))
|
|
}
|
|
|
|
fun requestMtu(len: Int): Unit = makeSync { queueRequestMtu(len, it) }
|
|
|
|
private var currentReliableWrite: ByteArray? = null
|
|
|
|
private fun queueWriteCharacteristic(
|
|
c: BluetoothGattCharacteristic,
|
|
v: ByteArray,
|
|
cont: Continuation<BluetoothGattCharacteristic>
|
|
) = queueWork("writeC ${c.uuid}", cont) {
|
|
currentReliableWrite = null
|
|
c.value = v
|
|
gatt!!.writeCharacteristic(c)
|
|
}
|
|
|
|
fun asyncWriteCharacteristic(
|
|
c: BluetoothGattCharacteristic,
|
|
v: ByteArray,
|
|
cb: (Result<BluetoothGattCharacteristic>) -> Unit
|
|
) = queueWriteCharacteristic(c, v, CallbackContinuation(cb))
|
|
|
|
fun writeCharacteristic(
|
|
c: BluetoothGattCharacteristic,
|
|
v: ByteArray
|
|
): BluetoothGattCharacteristic =
|
|
makeSync { queueWriteCharacteristic(c, v, it) }
|
|
|
|
/** Like write, but we use the extra reliable flow documented here:
|
|
* https://stackoverflow.com/questions/24485536/what-is-reliable-write-in-ble
|
|
*/
|
|
private fun queueWriteReliable(
|
|
c: BluetoothGattCharacteristic,
|
|
cont: Continuation<Unit>
|
|
) = queueWork("rwriteC ${c.uuid}", cont) {
|
|
logAssert(gatt!!.beginReliableWrite())
|
|
currentReliableWrite = c.value.clone()
|
|
gatt!!.writeCharacteristic(c)
|
|
}
|
|
|
|
/* fun asyncWriteReliable(
|
|
c: BluetoothGattCharacteristic,
|
|
cb: (Result<Unit>) -> Unit
|
|
) = queueWriteCharacteristic(c, CallbackContinuation(cb)) */
|
|
|
|
fun writeReliable(c: BluetoothGattCharacteristic): Unit =
|
|
makeSync { queueWriteReliable(c, it) }
|
|
|
|
private fun queueWriteDescriptor(
|
|
c: BluetoothGattDescriptor,
|
|
cont: Continuation<BluetoothGattDescriptor>
|
|
) = queueWork("writeD", cont) { gatt!!.writeDescriptor(c) }
|
|
|
|
fun asyncWriteDescriptor(
|
|
c: BluetoothGattDescriptor,
|
|
cb: (Result<BluetoothGattDescriptor>) -> Unit
|
|
) = queueWriteDescriptor(c, CallbackContinuation(cb))
|
|
|
|
|
|
/** Close just the GATT device but keep our pending callbacks active */
|
|
fun closeGatt() {
|
|
|
|
gatt?.let { g ->
|
|
info("Closing our GATT connection")
|
|
gatt =
|
|
null // Clear this first so the onConnectionChange callback can ignore while we are shutting down
|
|
g.disconnect()
|
|
g.close()
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Close down any existing connection, any existing calls (including async connects will be
|
|
* cancelled and you'll need to recall connect to use this againt
|
|
*/
|
|
fun closeConnection() {
|
|
// Set these to null _before_ calling gatt.disconnect(), because we don't want the old lostConnectCallback to get called
|
|
lostConnectCallback = null
|
|
connectionCallback = null
|
|
|
|
// Cancel any notifications - because when the device comes back it might have forgotten about us
|
|
notifyHandlers.clear()
|
|
|
|
closeGatt()
|
|
|
|
ignoreException {
|
|
// Hmm - sometimes the "Connection closing" exception comes back to us - ignore it
|
|
failAllWork(BLEException("Connection closing"))
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Close and destroy this SafeBluetooth instance. You'll need to make a new instance before using it again
|
|
*/
|
|
override fun close() {
|
|
closeConnection()
|
|
|
|
context.unregisterReceiver(btStateReceiver)
|
|
}
|
|
|
|
|
|
/// asyncronously turn notification on/off for a characteristic
|
|
fun setNotify(
|
|
c: BluetoothGattCharacteristic,
|
|
enable: Boolean,
|
|
onChanged: (BluetoothGattCharacteristic) -> Unit
|
|
) {
|
|
debug("starting setNotify(${c.uuid}, $enable)")
|
|
notifyHandlers[c.uuid] = onChanged
|
|
// c.writeType = BluetoothGattCharacteristic.WRITE_TYPE_DEFAULT
|
|
gatt!!.setCharacteristicNotification(c, enable)
|
|
|
|
/*
|
|
c is null sometimes
|
|
2020-04-13 15:59:38.222 2111-2182/com.geeksville.mesh D/BluetoothGatt: setCharacteristicNotification() - uuid: ed9da18c-a800-4f66-a670-aa7547e34453 enable: true
|
|
2020-04-13 15:59:38.225 2111-2182/com.geeksville.mesh E/com.geeksville.util.Exceptions: exceptionReporter Uncaught Exception
|
|
kotlin.KotlinNullPointerException
|
|
at com.geeksville.mesh.service.SafeBluetooth.setNotify(SafeBluetooth.kt:505)
|
|
at com.geeksville.mesh.service.RadioInterfaceService$onConnect$1$1.invoke(RadioInterfaceService.kt:328)
|
|
at com.geeksville.mesh.service.RadioInterfaceService$onConnect$1$1.invoke(RadioInterfaceService.kt:90)
|
|
at com.geeksville.concurrent.CallbackContinuation.resume(SyncContinuation.kt:20)
|
|
at com.geeksville.mesh.service.SafeBluetooth$completeWork$1.invoke(SafeBluetooth.kt:329)
|
|
at com.geeksville.mesh.service.SafeBluetooth$completeWork$1.invoke(SafeBluetooth.kt:33)
|
|
at com.geeksville.util.ExceptionsKt.exceptionReporter(Exceptions.kt:34)
|
|
at com.geeksville.mesh.service.SafeBluetooth.completeWork(SafeBluetooth.kt:312)
|
|
at com.geeksville.mesh.service.SafeBluetooth.access$completeWork(SafeBluetooth.kt:33)
|
|
at com.geeksville.mesh.service.SafeBluetooth$gattCallback$1.onMtuChanged(SafeBluetooth.kt:221)
|
|
at android.bluetooth.BluetoothGatt$1$13.run(BluetoothGatt.java:658)
|
|
at android.bluetooth.BluetoothGatt.runOrQueueCallback(BluetoothGatt.java:780)
|
|
at android.bluetooth.BluetoothGatt.access$200(BluetoothGatt.java:41)
|
|
at android.bluetooth.BluetoothGatt$1.onConfigureMTU(BluetoothGatt.java:653)
|
|
at android.bluetooth.IBluetoothGattCallback$Stub.onTransact(IBluetoothGattCallback.java:330)
|
|
at android.os.Binder.execTransactInternal(Binder.java:1021)
|
|
at android.os.Binder.execTransact(Binder.java:994)
|
|
*/
|
|
// per https://stackoverflow.com/questions/27068673/subscribe-to-a-ble-gatt-notification-android
|
|
val descriptor: BluetoothGattDescriptor = c.getDescriptor(configurationDescriptorUUID)
|
|
?: throw BLEException("Notify descriptor not found for ${c.uuid}") // This can happen on buggy BLE implementations
|
|
descriptor.value =
|
|
if (enable) BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE else BluetoothGattDescriptor.DISABLE_NOTIFICATION_VALUE
|
|
asyncWriteDescriptor(descriptor) {
|
|
debug("Notify enable=$enable completed")
|
|
}
|
|
}
|
|
}
|
|
|