WIP Add a server component

Author: hufman

.idea/codeStyles/Project.xml

@@ -19,15 +19,15 @@
         android:dataExtractionRules="@xml/data_extraction_rules"
         android:fullBackupContent="@xml/backup_rules"
         android:icon="@mipmap/ic_launcher"
-        android:label="@string/app_name"
+        android:label="@string/app_name_client"
         android:roundIcon="@mipmap/ic_launcher_round"
         android:supportsRtl="true"
         android:theme="@style/Theme.BclClient"
         tools:targetApi="31">
         <activity
-            android:name=".MainActivity"
+            android:name=".BclClientActivity"
             android:exported="true"
-            android:label="@string/app_name"
+            android:label="@string/app_name_client"
             android:theme="@style/Theme.BclClient.NoActionBar">
             <intent-filter>
                 <action android:name="android.intent.action.MAIN" />
@@ -40,7 +40,23 @@
                 android:value="" />
         </activity>
 
-        <service android:name="io.bimmergestalt.bclclient.MainService"
+        <activity
+            android:name="io.bimmergestalt.bclserver.BclServerActivity"
+            android:exported="true"
+            android:label="@string/app_name_server"
+            android:theme="@style/Theme.BclClient.NoActionBar">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+
+            <meta-data
+                android:name="android.app.lib_name"
+                android:value="" />
+        </activity>
+
+        <service android:name="io.bimmergestalt.bclclient.BclClientService"
             android:exported="false"
             android:foregroundServiceType="connectedDevice"/>
         <service android:name="io.bimmergestalt.bcl.android.BtClientService"

.idea/compiler.xml

@@ -71,7 +71,13 @@ open class BclPacket(
 			override fun toString(): String {
 				return "BclPacket\$Handshake(version=$version, instanceId=$instanceId, bufferSize=0x${bufferSize.toString(16)})"
 			}
-
+		}
+		fun Handshake(version: Short, instanceId: Short, bufferSize: Int): Handshake {
+			return Handshake().apply {
+				this.version = version
+				this.instanceId = instanceId
+				this.bufferSize = bufferSize
+			}
 		}
 		class SelectProto(data: ByteArray = ByteArray(2)): BclPacket(COMMAND.SELECTPROTO, 0, 0, data) {
 			var version by ShortField(data, 0)

.idea/gradle.xml

@@ -0,0 +1,86 @@
+package io.bimmergestalt.bcl.android
+
+import android.bluetooth.BluetoothAdapter
+import android.bluetooth.BluetoothServerSocket
+import android.bluetooth.BluetoothSocket
+import io.bimmergestalt.bcl.ConnectionState
+import io.bimmergestalt.bcl.MutableConnectionState
+import io.bimmergestalt.bcl.multiplex.BclDemuxer
+import io.bimmergestalt.bcl.protocols.DemuxedProtocolFactory
+import io.bimmergestalt.bcl.server.BclServerTransport
+import org.tinylog.kotlin.Logger
+import java.io.IOException
+
+class BtServerConnection(val adapter: BluetoothAdapter, val connectionState: MutableConnectionState,
+                         val protocolFactories: Iterable<DemuxedProtocolFactory>): Thread() {
+
+	private var socket: BluetoothServerSocket? = null
+
+	var bclConnection: BclServerTransport? = null
+		private set
+	var bclDemuxer: BclDemuxer? = null
+		private set
+
+	override fun run() {
+		connectionState.transportState = ConnectionState.TransportState.OPENING
+		val serverSocket = try {
+			adapter.listenUsingRfcommWithServiceRecord("BCL", BtConnection.SDP_BCL)
+		} catch (_: SecurityException) {
+			return
+		}
+		this.socket = serverSocket
+
+		try {
+			val socket = connectSocket(serverSocket)
+			connectBcl(socket)
+		} catch (_: SecurityException) {
+			return
+		} catch (_: InterruptedException) {
+			return
+		}
+	}
+
+	private fun connectSocket(serverSocket: BluetoothServerSocket): BluetoothSocket {
+		connectionState.transportState = ConnectionState.TransportState.OPENING
+		try {
+			return serverSocket.accept()
+		} catch (e: SecurityException) {
+			throw e
+		} catch (e: IOException) {
+			connectionState.transportState = ConnectionState.TransportState.FAILED
+			Logger.warn(e) { "IOException opening BluetoothSocket" }
+			throw e
+		}
+	}
+
+	private fun connectBcl(socket: BluetoothSocket) {
+		while (socket.isConnected) {
+			try {
+				connectionState.transportState = ConnectionState.TransportState.ACTIVE
+				val bclConnection = BclServerTransport(socket.inputStream, socket.outputStream, connectionState)
+				this.bclConnection = bclConnection
+				bclConnection.connect()
+				val bclDemuxer = BclDemuxer(bclConnection, protocolFactories)
+				this.bclDemuxer = bclDemuxer
+				bclDemuxer.run()
+			} catch (_: SecurityException) {
+			} catch (e: IOException) {
+				Logger.warn(e) { "IOException communicating BCL" }
+			} catch (_: InterruptedException) {
+			} finally {
+				bclDemuxer?.shutdown()
+				bclDemuxer = null
+				bclConnection?.shutdown()
+				bclConnection = null
+			}
+			connectionState.transportState = ConnectionState.TransportState.WAITING
+			sleep(1000)
+		}
+	}
+
+	fun shutdown() {
+		bclConnection?.shutdown()
+		socket?.close()
+		interrupt()
+	}
+}

.idea/misc.xml

@@ -0,0 +1,127 @@
+package io.bimmergestalt.bcl.android
+
+import android.Manifest
+import android.annotation.SuppressLint
+import android.app.Service
+import android.bluetooth.BluetoothDevice
+import android.bluetooth.BluetoothManager
+import android.bluetooth.BluetoothServerSocket
+import android.content.Intent
+import android.os.*
+import android.util.ArrayMap
+import androidx.core.content.PermissionChecker
+import androidx.lifecycle.LiveData
+import io.bimmergestalt.bcl.ConnectionState
+import io.bimmergestalt.bcl.android.BtConnection.Companion.SDP_BCL
+import org.tinylog.kotlin.Logger
+import java.io.IOException
+import java.util.*
+
+
+class BtServerService: Service() {
+
+	companion object {
+		private val _state = ConnectionStateLiveData()
+		val state: LiveData<ConnectionState> = _state
+		private const val INTERVAL_SCAN: Int = 2000
+		private const val INTERVAL_KEEPALIVE: Int = 10000
+		private const val ETCH_PROXY_PORT: Short = 4007
+		private const val ETCH_DEST_PORT: Short = 4004
+		val ACTION_SHUTDOWN = "io.bimmergestalt.bcl.android.BtServerService.SHUTDOWN"
+	}
+
+	// on startup, check for Bluetooth Connect privilege, stop self if not
+	// prune any disconnected sockets
+	// scan all the Adapters for car devices
+	// create connections if not already connected
+	// socket connection is blocking for up to 12s timeout
+	// each socket needs its own Thread
+
+	private val handlerThread = HandlerThread("BtServerService")
+	private val handler = Handler(handlerThread.looper)
+	private var serverSocket: BluetoothServerSocket? = null
+	private val btThreads = ArrayMap<String, BtConnection>()      // bt address to thread
+
+
+	override fun onBind(intent: Intent?): IBinder? {
+		return null
+	}
+
+	override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
+		if (!hasBluetoothPermission()) {
+			Logger.warn { "Bluetooth permission is missing, not starting" }
+			stopSelf(startId)
+			return START_NOT_STICKY
+		}
+		if (intent?.action != ACTION_SHUTDOWN) {
+			startServer()
+		} else {
+			stopSelf()
+		}
+		return START_STICKY
+	}
+
+	private fun hasBluetoothPermission(): Boolean {
+		if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+			if (PermissionChecker.checkSelfPermission(this, Manifest.permission.BLUETOOTH_CONNECT) == PermissionChecker.PERMISSION_GRANTED) {
+				return true
+			}
+		} else {
+			if (PermissionChecker.checkSelfPermission(this, Manifest.permission.BLUETOOTH) == PermissionChecker.PERMISSION_GRANTED) {
+				return true
+			}
+		}
+		return false
+	}
+
+	@SuppressLint("MissingPermission")
+	private fun startServer() {
+		val server = this.getSystemService(BluetoothManager::class.java).adapter.listenUsingRfcommWithServiceRecord("BCL", SDP_BCL)
+		serverSocket = server
+		handlerThread.start()
+		handler.post {
+			acceptConnections()
+		}
+	}
+
+	private fun acceptConnections() {
+		while (true) {
+			try {
+				val connection = serverSocket?.accept()
+				// wrap in BtConnection
+			} catch (e: IOException) {
+				Logger.info("Received error when accepting server connection, shutting down")
+				return
+			}
+		}
+	}
+
+	private fun tryConnection(device: BluetoothDevice): BtConnection {
+		return BtConnection(device, _state, listOf(
+			BclTunnelReport.Factory(this, device.brand ?: "bmw"),
+			EtchProxyService.Factory(this, ETCH_PROXY_PORT, ETCH_DEST_PORT,
+				device.brand ?: "bmw", _state)
+		))
+	}
+
+	private fun stopServer() {
+		serverSocket?.close()
+		handlerThread.looper.quit()
+	}
+
+	private fun disconnect() {
+		Logger.info {"Shutting down BtServerService"}
+		synchronized(btThreads) {
+			btThreads.values.forEach {
+				it?.shutdown()
+			}
+			btThreads.clear()
+		}
+	}
+
+	override fun onDestroy() {
+		super.onDestroy()
+		stopServer()
+		disconnect()
+	}
+}

app/src/main/AndroidManifest.xml

@@ -133,9 +133,10 @@ class BclClientTransport(input: InputStream, output: OutputStream, val connectio
 		try {
 			packetOutput.writePacket(BclPacket(BclPacket.COMMAND.HANGUP, 0, 0, ByteArray(0)))
 			output.flush()
-			state = ConnectionState.BclState.SHUTDOWN
 		} catch (e: Exception) {
 			Logger.warn(e) {"Error while shutting down BCL"}
+		} finally {
+			state = ConnectionState.BclState.SHUTDOWN
 		}
 	}
 }