251 lines
6.9 KiB
Kotlin
251 lines
6.9 KiB
Kotlin
package llc.arma.ble.data
|
|
|
|
import android.Manifest
|
|
import android.app.Application
|
|
import android.bluetooth.BluetoothGatt
|
|
import android.bluetooth.BluetoothGattCallback
|
|
import android.bluetooth.BluetoothGattCharacteristic
|
|
import android.bluetooth.BluetoothProfile
|
|
import android.content.pm.PackageManager
|
|
import android.os.Build
|
|
import android.util.Log
|
|
import androidx.core.app.ActivityCompat
|
|
import kotlinx.coroutines.CoroutineScope
|
|
import kotlinx.coroutines.Dispatchers
|
|
import kotlinx.coroutines.delay
|
|
import kotlinx.coroutines.launch
|
|
import llc.arma.ble.domain.Result
|
|
import llc.arma.ble.domain.common.BleException
|
|
import llc.arma.ble.domain.model.Ble
|
|
import java.util.UUID
|
|
|
|
class WriteThermometerCallback(
|
|
private val app: Application,
|
|
private var request: Ble.Thermometer.WriteRequest,
|
|
private val onResult: (Result<Unit, BleException>) -> Unit
|
|
) : BluetoothGattCallback() {
|
|
|
|
private var flashed = false
|
|
|
|
override fun onConnectionStateChange(
|
|
gatt: BluetoothGatt,
|
|
status: Int,
|
|
newState: Int
|
|
) {
|
|
super.onConnectionStateChange(gatt, status, newState)
|
|
|
|
Log.d("th", "onConnectionStateChange $status $newState")
|
|
|
|
if(checkPermission()) {
|
|
|
|
if(status == BluetoothGatt.GATT_SUCCESS && newState == BluetoothProfile.STATE_CONNECTED) {
|
|
|
|
gatt.discoverServices()
|
|
|
|
} else {
|
|
|
|
onResult(Result.failure(BleException.UnexpectedResponse))
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
onResult(Result.failure(BleException.PermissionDenied))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
override fun onServicesDiscovered(
|
|
gatt: BluetoothGatt,
|
|
status: Int
|
|
) {
|
|
Log.d("th", "onServicesDiscovered $status")
|
|
super.onServicesDiscovered(gatt, status)
|
|
onCycle(gatt, status)
|
|
|
|
}
|
|
|
|
private fun onCycle(
|
|
gatt: BluetoothGatt,
|
|
status: Int
|
|
){
|
|
|
|
if(request.tx != null || request.saveHistory != null || request.historyInterval != null) {
|
|
|
|
fun UInt.to4ByteArrayInLittleEndian(): ByteArray =
|
|
(3 downTo 0).map {
|
|
(this shr (it * Byte.SIZE_BITS)).toByte()
|
|
}.toByteArray()
|
|
|
|
var uuid: Pair<UUID, ByteArray>? = null
|
|
|
|
uuid = request.historyInterval?.let {
|
|
|
|
this.request = request.copy(
|
|
historyInterval = null
|
|
)
|
|
|
|
Pair(
|
|
intervalWriteUUID,
|
|
mutableListOf<Byte>(3).apply {
|
|
addAll((it).toUInt().to4ByteArrayInLittleEndian().reversed().toList())
|
|
}.toByteArray()
|
|
)
|
|
}
|
|
|
|
uuid = request.saveHistory?.let {
|
|
|
|
this.request = request.copy(
|
|
saveHistory = null
|
|
)
|
|
|
|
Pair(
|
|
saveEnabledWriteUUID,
|
|
mutableListOf<Byte>(4).apply {
|
|
add(if (it) 1 else 0)
|
|
}.toByteArray()
|
|
)
|
|
} ?: uuid
|
|
|
|
uuid = request.tx?.let {
|
|
|
|
this.request = request.copy(
|
|
tx = null
|
|
)
|
|
|
|
Pair(
|
|
txWriteUUID,
|
|
byteArrayOf(
|
|
when (it) {
|
|
Ble.BleState.TX.MINUS_40 -> -40
|
|
Ble.BleState.TX.MINUS_20 -> -20
|
|
Ble.BleState.TX.MINUS_16 -> -16
|
|
Ble.BleState.TX.MINUS_12 -> -12
|
|
Ble.BleState.TX.MINUS_8 -> -8
|
|
Ble.BleState.TX.MINUS_4 -> -4
|
|
Ble.BleState.TX.ZERO -> 0
|
|
Ble.BleState.TX.PLUS_3 -> 3
|
|
Ble.BleState.TX.PLUS_4 -> 4
|
|
}
|
|
)
|
|
)
|
|
|
|
} ?: uuid
|
|
|
|
uuid?.let { uuid ->
|
|
|
|
gatt.services.firstOrNull { it.uuid == serviceUUID }?.characteristics?.firstOrNull {
|
|
it.uuid == uuid.first
|
|
}?.let {
|
|
|
|
gatt.writeCharacteristic(it, uuid.second)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
}
|
|
|
|
onResult(Result.failure(BleException.UnexpectedResponse))
|
|
|
|
} else {
|
|
|
|
if(flashed.not()){
|
|
|
|
flashed = true
|
|
|
|
gatt.services.firstOrNull { it.uuid == serviceUUID }?.characteristics?.firstOrNull {
|
|
it.uuid == flashWriteUUID
|
|
}?.let {
|
|
|
|
gatt.writeCharacteristic(it, byteArrayOf(9))
|
|
|
|
return
|
|
|
|
}
|
|
|
|
onResult(Result.failure(BleException.UnexpectedResponse))
|
|
|
|
} else {
|
|
|
|
onResult(Result.success(Unit))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
override fun onCharacteristicWrite(
|
|
gatt: BluetoothGatt,
|
|
characteristic: BluetoothGattCharacteristic,
|
|
status: Int
|
|
) {
|
|
|
|
Log.d("th", "onCharacteristicWrite $status")
|
|
|
|
super.onCharacteristicWrite(gatt, characteristic, status)
|
|
|
|
if(checkPermission()) {
|
|
|
|
if(status == BluetoothGatt.GATT_SUCCESS || flashed) {
|
|
|
|
onCycle(gatt, status)
|
|
|
|
} else {
|
|
|
|
onResult(Result.failure(BleException.UnexpectedResponse))
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
onResult(Result.failure(BleException.PermissionDenied))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
private fun BluetoothGatt.writeCharacteristic(
|
|
characteristic: BluetoothGattCharacteristic,
|
|
data: ByteArray
|
|
): Result<Unit, BleException> {
|
|
|
|
return if(checkPermission()){
|
|
|
|
Log.d("write", data.asUByteArray().joinToString(" ") { it.toString(16).padStart(2, '0') })
|
|
|
|
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
|
|
writeCharacteristic(characteristic, data, BluetoothGattCharacteristic.WRITE_TYPE_DEFAULT)
|
|
}else{
|
|
|
|
characteristic.writeType = BluetoothGattCharacteristic.WRITE_TYPE_DEFAULT
|
|
characteristic.value = data
|
|
writeCharacteristic(characteristic)
|
|
}
|
|
|
|
Result.success(Unit)
|
|
|
|
} else {
|
|
Result.failure(BleException.PermissionDenied)
|
|
}
|
|
|
|
}
|
|
|
|
private fun checkPermission(): Boolean {
|
|
|
|
return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
|
|
ActivityCompat.checkSelfPermission(app, Manifest.permission.BLUETOOTH_CONNECT) ==
|
|
PackageManager.PERMISSION_GRANTED &&
|
|
ActivityCompat.checkSelfPermission(app, Manifest.permission.BLUETOOTH_SCAN) ==
|
|
PackageManager.PERMISSION_GRANTED
|
|
} else {
|
|
return ActivityCompat.checkSelfPermission(app, Manifest.permission.ACCESS_FINE_LOCATION) ==
|
|
PackageManager.PERMISSION_GRANTED &&
|
|
ActivityCompat.checkSelfPermission(app, Manifest.permission.ACCESS_COARSE_LOCATION) ==
|
|
PackageManager.PERMISSION_GRANTED
|
|
}
|
|
}
|
|
|
|
} |