310 lines
12 KiB
Kotlin
310 lines
12 KiB
Kotlin
package eu.ztsh.garmin.bt
|
|
|
|
import android.annotation.SuppressLint
|
|
import android.bluetooth.BluetoothAdapter
|
|
import android.bluetooth.BluetoothDevice
|
|
import android.bluetooth.BluetoothSocket
|
|
import android.content.BroadcastReceiver
|
|
import android.content.Context
|
|
import android.content.Intent
|
|
import android.content.IntentFilter
|
|
import android.os.AsyncTask
|
|
import android.util.Log
|
|
import androidx.localbroadcastmanager.content.LocalBroadcastManager
|
|
import eu.ztsh.garmin.MainActivity
|
|
import java.io.IOException
|
|
import java.io.InputStream
|
|
import java.io.OutputStream
|
|
import java.util.*
|
|
|
|
class BluetoothSerial(var context: MainActivity, var messageHandler: MessageHandler, devicePrefix: String) {
|
|
var connected = false
|
|
var bluetoothDevice: BluetoothDevice? = null
|
|
var serialSocket: BluetoothSocket? = null
|
|
var serialInputStream: InputStream? = null
|
|
var serialOutputStream: OutputStream? = null
|
|
var serialReader: SerialReader? = null
|
|
var connectionTask: AsyncTask<Void?, Void?, BluetoothDevice?>? = null
|
|
var devicePrefix: String
|
|
|
|
/**
|
|
* Listens for discount message from bluetooth system and restablishing a connection
|
|
*/
|
|
private val bluetoothReceiver: BroadcastReceiver = object : BroadcastReceiver() {
|
|
override fun onReceive(context: Context, intent: Intent) {
|
|
val action = intent.action
|
|
val eventDevice = intent.getParcelableExtra<BluetoothDevice>(BluetoothDevice.EXTRA_DEVICE)
|
|
if (BluetoothDevice.ACTION_ACL_DISCONNECTED == action) {
|
|
if (bluetoothDevice != null && bluetoothDevice == eventDevice) {
|
|
Log.i(BMX_BLUETOOTH, "Received bluetooth disconnect notice")
|
|
|
|
//clean up any streams
|
|
close()
|
|
|
|
//reestablish connect
|
|
connect()
|
|
LocalBroadcastManager.getInstance(context).sendBroadcast(Intent(BLUETOOTH_DISCONNECTED))
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
init {
|
|
this.devicePrefix = devicePrefix.uppercase(Locale.getDefault())
|
|
}
|
|
|
|
fun onPause() {
|
|
context.unregisterReceiver(bluetoothReceiver)
|
|
}
|
|
|
|
fun onResume() {
|
|
//listen for bluetooth disconnect
|
|
val disconnectIntent = IntentFilter(BluetoothDevice.ACTION_ACL_DISCONNECTED)
|
|
context.registerReceiver(bluetoothReceiver, disconnectIntent)
|
|
|
|
//reestablishes a connection is one doesn't exist
|
|
if (!connected) {
|
|
connect()
|
|
} else {
|
|
val intent = Intent(BLUETOOTH_CONNECTED)
|
|
LocalBroadcastManager.getInstance(context).sendBroadcast(intent)
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Initializes the bluetooth serial connections, uses the LocalBroadcastManager when
|
|
* connection is established
|
|
*/
|
|
@SuppressLint("MissingPermission")
|
|
fun connect() {
|
|
if (connected) {
|
|
Log.e(BMX_BLUETOOTH, "Connection request while already connected")
|
|
return
|
|
}
|
|
if (connectionTask != null && connectionTask!!.status == AsyncTask.Status.RUNNING) {
|
|
Log.e(BMX_BLUETOOTH, "Connection request while attempting connection")
|
|
return
|
|
}
|
|
val bluetoothAdapter = BluetoothAdapter.getDefaultAdapter()
|
|
if (bluetoothAdapter == null || !bluetoothAdapter.isEnabled) {
|
|
return
|
|
}
|
|
context.checkBt()
|
|
val pairedDevices: List<BluetoothDevice> = ArrayList(bluetoothAdapter.getBondedDevices())
|
|
if (pairedDevices.isNotEmpty()) {
|
|
bluetoothAdapter.cancelDiscovery()
|
|
/**
|
|
* AsyncTask to handle the establishing of a bluetooth connection
|
|
*/
|
|
// connectionTask = object : AsyncTask<Void?, Void?, BluetoothDevice?>() {
|
|
// var MAX_ATTEMPTS = 30
|
|
// var attemptCounter = 0
|
|
// protected override fun doInBackground(vararg params: Void): BluetoothDevice? {
|
|
// while (!isCancelled) { //need to kill without calling onCancel
|
|
// for (device in pairedDevices) {
|
|
// if (device.getName().uppercase(Locale.getDefault()).startsWith(devicePrefix)) {
|
|
// Log.i(
|
|
// BMX_BLUETOOTH,
|
|
// attemptCounter.toString() + ": Attempting connection to " + device.getName()
|
|
// )
|
|
// try {
|
|
// serialSocket = try {
|
|
// // Standard SerialPortService ID
|
|
// val uuid = UUID.fromString("00001101-0000-1000-8000-00805F9B34FB")
|
|
// device.createRfcommSocketToServiceRecord(uuid)
|
|
// } catch (ce: Exception) {
|
|
// connectViaReflection(device)
|
|
// }
|
|
//
|
|
// //setup the connect streams
|
|
// serialSocket!!.connect()
|
|
// serialInputStream = serialSocket!!.inputStream
|
|
// serialOutputStream = serialSocket!!.outputStream
|
|
// connected = true
|
|
// Log.i(BMX_BLUETOOTH, "Connected to " + device.getName())
|
|
// return device
|
|
// } catch (e: Exception) {
|
|
// serialSocket = null
|
|
// serialInputStream = null
|
|
// serialOutputStream = null
|
|
// Log.i(BMX_BLUETOOTH, e.message!!)
|
|
// }
|
|
// }
|
|
// }
|
|
// try {
|
|
// attemptCounter++
|
|
// if (attemptCounter > MAX_ATTEMPTS) cancel(false) else Thread.sleep(1000)
|
|
// } catch (e: InterruptedException) {
|
|
// break
|
|
// }
|
|
// }
|
|
// Log.i(BMX_BLUETOOTH, "Stopping connection attempts")
|
|
// val intent = Intent(BLUETOOTH_FAILED)
|
|
// LocalBroadcastManager.getInstance(context).sendBroadcast(intent)
|
|
// return null
|
|
// }
|
|
//
|
|
// override fun onPostExecute(result: BluetoothDevice?) {
|
|
// super.onPostExecute(result)
|
|
// bluetoothDevice = result
|
|
//
|
|
// //start thread responsible for reading from inputstream
|
|
// serialReader = SerialReader()
|
|
// serialReader!!.start()
|
|
//
|
|
// //send connection message
|
|
// val intent = Intent(BLUETOOTH_CONNECTED)
|
|
// LocalBroadcastManager.getInstance(context).sendBroadcast(intent)
|
|
// }
|
|
// }
|
|
// connectionTask.execute()
|
|
}
|
|
}
|
|
|
|
// see: http://stackoverflow.com/questions/3397071/service-discovery-failed-exception-using-bluetooth-on-android
|
|
@Throws(Exception::class)
|
|
private fun connectViaReflection(device: BluetoothDevice): BluetoothSocket {
|
|
val m = device.javaClass.getMethod(
|
|
"createRfcommSocket", *arrayOf<Class<*>?>(
|
|
Int::class.javaPrimitiveType
|
|
)
|
|
)
|
|
return m.invoke(device, 1) as BluetoothSocket
|
|
}
|
|
|
|
@Throws(IOException::class)
|
|
fun available(): Int {
|
|
if (connected) return serialInputStream!!.available()
|
|
throw RuntimeException("Connection lost, reconnecting now.")
|
|
}
|
|
|
|
@Throws(IOException::class)
|
|
fun read(): Int {
|
|
if (connected) return serialInputStream!!.read()
|
|
throw RuntimeException("Connection lost, reconnecting now.")
|
|
}
|
|
|
|
@Throws(IOException::class)
|
|
fun read(buffer: ByteArray?): Int {
|
|
if (connected) return serialInputStream!!.read(buffer)
|
|
throw RuntimeException("Connection lost, reconnecting now.")
|
|
}
|
|
|
|
@Throws(IOException::class)
|
|
fun read(buffer: ByteArray?, byteOffset: Int, byteCount: Int): Int {
|
|
if (connected) return serialInputStream!!.read(buffer, byteOffset, byteCount)
|
|
throw RuntimeException("Connection lost, reconnecting now.")
|
|
}
|
|
|
|
@Throws(IOException::class)
|
|
fun write(buffer: ByteArray?) {
|
|
if (connected) serialOutputStream!!.write(buffer)
|
|
throw RuntimeException("Connection lost, reconnecting now.")
|
|
}
|
|
|
|
@Throws(IOException::class)
|
|
fun write(oneByte: Int) {
|
|
if (connected) serialOutputStream!!.write(oneByte)
|
|
throw RuntimeException("Connection lost, reconnecting now.")
|
|
}
|
|
|
|
@Throws(IOException::class)
|
|
fun write(buffer: ByteArray?, offset: Int, count: Int) {
|
|
serialOutputStream!!.write(buffer, offset, count)
|
|
throw RuntimeException("Connection lost, reconnecting now.")
|
|
}
|
|
|
|
inner class SerialReader : Thread() {
|
|
var buffer = ByteArray(Companion.MAX_BYTES)
|
|
var bufferSize = 0
|
|
override fun run() {
|
|
Log.i("serialReader", "Starting serial loop")
|
|
while (!isInterrupted) {
|
|
try {
|
|
|
|
/*
|
|
* check for some bytes, or still bytes still left in
|
|
* buffer
|
|
*/
|
|
if (available() > 0) {
|
|
val newBytes = read(buffer, bufferSize, Companion.MAX_BYTES - bufferSize)
|
|
if (newBytes > 0) bufferSize += newBytes
|
|
Log.d(BMX_BLUETOOTH, "read $newBytes")
|
|
}
|
|
if (bufferSize > 0) {
|
|
val read = messageHandler.read(bufferSize, buffer)
|
|
|
|
// shift unread data to start of buffer
|
|
if (read > 0) {
|
|
var index = 0
|
|
for (i in read until bufferSize) {
|
|
buffer[index++] = buffer[i]
|
|
}
|
|
bufferSize = index
|
|
}
|
|
} else {
|
|
try {
|
|
sleep(10)
|
|
} catch (ie: InterruptedException) {
|
|
break
|
|
}
|
|
}
|
|
} catch (e: Exception) {
|
|
Log.e(BMX_BLUETOOTH, "Error reading serial data", e)
|
|
}
|
|
}
|
|
Log.i(BMX_BLUETOOTH, "Shutting serial loop")
|
|
}
|
|
|
|
// companion object {
|
|
// }
|
|
}
|
|
|
|
/**
|
|
* Reads from the serial buffer, processing any available messages. Must return the number of bytes
|
|
* consumer from the buffer
|
|
*
|
|
* @author jpetrocik
|
|
*/
|
|
fun interface MessageHandler {
|
|
fun read(bufferSize: Int, buffer: ByteArray?): Int
|
|
}
|
|
|
|
fun close() {
|
|
connected = false
|
|
if (connectionTask != null) {
|
|
connectionTask!!.cancel(false)
|
|
}
|
|
if (serialReader != null) {
|
|
serialReader!!.interrupt()
|
|
try {
|
|
serialReader!!.join(1000)
|
|
} catch (ie: InterruptedException) {
|
|
}
|
|
}
|
|
try {
|
|
serialInputStream!!.close()
|
|
} catch (e: Exception) {
|
|
Log.e(BMX_BLUETOOTH, "Failed releasing inputstream connection")
|
|
}
|
|
try {
|
|
serialOutputStream!!.close()
|
|
} catch (e: Exception) {
|
|
Log.e(BMX_BLUETOOTH, "Failed releasing outputstream connection")
|
|
}
|
|
try {
|
|
serialSocket!!.close()
|
|
} catch (e: Exception) {
|
|
Log.e(BMX_BLUETOOTH, "Failed closing socket")
|
|
}
|
|
Log.i(BMX_BLUETOOTH, "Released bluetooth connections")
|
|
}
|
|
|
|
companion object {
|
|
private const val BMX_BLUETOOTH = "BMXBluetooth"
|
|
var BLUETOOTH_CONNECTED = "bluetooth-connection-started"
|
|
var BLUETOOTH_DISCONNECTED = "bluetooth-connection-lost"
|
|
var BLUETOOTH_FAILED = "bluetooth-connection-failed"
|
|
private const val MAX_BYTES = 125
|
|
}
|
|
}
|