RFCOMM Client BumbleBluetooth: Connect am: d8db127887 am: 9d195ba5c0 (aa48ac70) · Commits · e / os / android_packages_modules_Bluetooth

framework/tests/bumble/src/android/bluetooth/PandoraDevice.java

+11 −0

Original line number	Diff line number	Diff line
		@@ -35,6 +35,7 @@ import pandora.DckGrpc;
		import pandora.GATTGrpc;
		import pandora.HostGrpc;
		import pandora.HostProto;
		import pandora.RFCOMMGrpc;
		import pandora.SecurityGrpc;

		public final class PandoraDevice extends ExternalResource {
		@@ -141,4 +142,14 @@ public final class PandoraDevice extends ExternalResource {
		public GATTGrpc.GATTBlockingStub gattBlocking() {
		return GATTGrpc.newBlockingStub(mChannel);
		}

		/** Get Pandora RFCOMM service */
		public RFCOMMGrpc.RFCOMMStub rfcomm() {
		return RFCOMMGrpc.newStub(mChannel);
		}

		/** Get Pandora RFCOMM blocking service */
		public RFCOMMGrpc.RFCOMMBlockingStub rfcommBlocking() {
		return RFCOMMGrpc.newBlockingStub(mChannel);
		}
		}

framework/tests/bumble/src/android/bluetooth/RfcommTest.kt

0 → 100644

+285 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2024 The Android Open Source Project
		*
		* 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
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/
		package android.bluetooth

		import android.Manifest
		import android.content.BroadcastReceiver
		import android.content.Context
		import android.content.Intent
		import android.content.IntentFilter
		import android.util.Log
		import androidx.test.core.app.ApplicationProvider
		import androidx.test.ext.junit.runners.AndroidJUnit4
		import androidx.test.platform.app.InstrumentationRegistry
		import com.android.compatibility.common.util.AdoptShellPermissionsRule
		import com.google.common.truth.Truth
		import io.grpc.stub.StreamObserver
		import java.time.Duration
		import java.util.UUID
		import java.util.concurrent.TimeUnit
		import kotlinx.coroutines.*
		import kotlinx.coroutines.channels.*
		import kotlinx.coroutines.flow.Flow
		import kotlinx.coroutines.flow.consumeAsFlow
		import kotlinx.coroutines.flow.first
		import org.junit.After
		import org.junit.Before
		import org.junit.Rule
		import org.junit.Test
		import org.junit.runner.RunWith
		import pandora.RfcommProto
		import pandora.RfcommProto.ServerId
		import pandora.RfcommProto.StartServerRequest
		import pandora.SecurityProto.PairingEvent
		import pandora.SecurityProto.PairingEventAnswer

		@kotlinx.coroutines.ExperimentalCoroutinesApi
		fun bondingFlow(context: Context, peer: BluetoothDevice, state: Int): Flow<Intent> {
		val channel = Channel<Intent>(Channel.UNLIMITED)
		val receiver: BroadcastReceiver =
		object : BroadcastReceiver() {
		override fun onReceive(context: Context, intent: Intent) {
		if (
		peer ==
		intent.getParcelableExtra(
		BluetoothDevice.EXTRA_DEVICE,
		BluetoothDevice::class.java
		)
		) {
		if (intent.getIntExtra(BluetoothDevice.EXTRA_BOND_STATE, -1) == state) {
		channel.trySendBlocking(intent)
		}
		}
		}
		}
		context.registerReceiver(receiver, IntentFilter(BluetoothDevice.ACTION_BOND_STATE_CHANGED))
		channel.invokeOnClose { context.unregisterReceiver(receiver) }
		return channel.consumeAsFlow()
		}

		class PairingResponder(
		private val mPeer: BluetoothDevice,
		private val mPairingEventIterator: Iterator<PairingEvent>,
		private val mPairingEventAnswerObserver: StreamObserver<PairingEventAnswer>
		) : BroadcastReceiver() {
		override fun onReceive(context: Context, intent: Intent) {
		when (intent.action) {
		BluetoothDevice.ACTION_PAIRING_REQUEST -> {
		if (
		mPeer ==
		intent.getParcelableExtra(
		BluetoothDevice.EXTRA_DEVICE,
		BluetoothDevice::class.java
		)
		) {
		if (
		BluetoothDevice.PAIRING_VARIANT_CONSENT ==
		intent.getIntExtra(BluetoothDevice.EXTRA_PAIRING_VARIANT, -1)
		) {
		mPeer.setPairingConfirmation(true)
		val pairingEvent: PairingEvent = mPairingEventIterator.next()
		Truth.assertThat(pairingEvent.hasJustWorks()).isTrue()
		mPairingEventAnswerObserver.onNext(
		PairingEventAnswer.newBuilder()
		.setEvent(pairingEvent)
		.setConfirm(true)
		.build()
		)
		}
		}
		}
		}
		}
		}

		@RunWith(AndroidJUnit4::class)
		class RfcommTest {
		private val mContext = ApplicationProvider.getApplicationContext<Context>()
		private val mManager = mContext.getSystemService(BluetoothManager::class.java)
		private val mAdapter = mManager!!.adapter

		// Gives shell permissions during the test.
		@Rule
		@JvmField
		val mPermissionsRule =
		AdoptShellPermissionsRule(
		InstrumentationRegistry.getInstrumentation().getUiAutomation(),
		Manifest.permission.BLUETOOTH_CONNECT,
		Manifest.permission.BLUETOOTH_PRIVILEGED
		)

		// Set up a Bumble Pandora device for the duration of the test.
		@Rule @JvmField val mBumble = PandoraDevice()

		private lateinit var mBumbleDevice: BluetoothDevice
		private lateinit var mPairingResponder: PairingResponder
		private lateinit var mPairingEventAnswerObserver: StreamObserver<PairingEventAnswer>
		private val mPairingEventStreamObserver: StreamObserverSpliterator<PairingEvent> =
		StreamObserverSpliterator()
		private var mConnectionCounter = 1

		@Before
		fun setUp() {
		mBumbleDevice = mBumble.remoteDevice
		mPairingEventAnswerObserver =
		mBumble
		.security()
		.withDeadlineAfter(GRPC_TIMEOUT.toMillis(), TimeUnit.MILLISECONDS)
		.onPairing(mPairingEventStreamObserver)

		val pairingFilter = IntentFilter(BluetoothDevice.ACTION_PAIRING_REQUEST)
		mPairingResponder =
		PairingResponder(
		mBumbleDevice,
		mPairingEventStreamObserver.iterator(),
		mPairingEventAnswerObserver
		)
		mContext.registerReceiver(mPairingResponder, pairingFilter)

		// TODO: Ideally we shouldn't need this, remove
		runBlocking { removeBondIfBonded(mBumbleDevice) }
		}

		@After
		fun tearDown() {
		mContext.unregisterReceiver(mPairingResponder)
		}

		@Test
		fun clientConnectToOpenServerSocketBondedInsecure() {
		startServer {
		val serverId = it
		runBlocking { withTimeout(BOND_TIMEOUT.toMillis()) { bondDevice(mBumbleDevice) } }

		// Insecure connection to RFCOMM Server
		val insecureSocket =
		mBumbleDevice.createInsecureRfcommSocketToServiceRecord(UUID.fromString(TEST_UUID))
		insecureSocket.connect()

		val connectionResponse =
		mBumble
		.rfcommBlocking()
		.withDeadlineAfter(GRPC_TIMEOUT.toMillis(), TimeUnit.MILLISECONDS)
		.acceptConnection(
		RfcommProto.AcceptConnectionRequest.newBuilder().setServer(serverId).build()
		)
		Truth.assertThat(connectionResponse.connection.id).isEqualTo(mConnectionCounter)
		Truth.assertThat(insecureSocket.isConnected).isTrue()
		}
		}

		@Test
		fun clientConnectToOpenServerSocketBondedSecure() {
		startServer {
		val serverId = it
		runBlocking { withTimeout(BOND_TIMEOUT.toMillis()) { bondDevice(mBumbleDevice) } }
		// Secure connection to RFCOMM Server
		val secureSocket =
		mBumbleDevice.createRfcommSocketToServiceRecord(UUID.fromString(TEST_UUID))
		secureSocket.connect()

		val connectionResponse =
		mBumble
		.rfcommBlocking()
		.withDeadlineAfter(GRPC_TIMEOUT.toMillis(), TimeUnit.MILLISECONDS)
		.acceptConnection(
		RfcommProto.AcceptConnectionRequest.newBuilder().setServer(serverId).build()
		)
		Truth.assertThat(connectionResponse.connection.id).isEqualTo(mConnectionCounter)
		Truth.assertThat(secureSocket.isConnected).isTrue()
		}
		}

		private fun createAndConnectSocket(
		isSecure: Boolean,
		server: ServerId
		): Pair<BluetoothSocket, RfcommProto.RfcommConnection> {
		val socket =
		if (isSecure) {
		mBumbleDevice.createRfcommSocketToServiceRecord(UUID.fromString(TEST_UUID))
		} else {
		mBumbleDevice.createInsecureRfcommSocketToServiceRecord(UUID.fromString(TEST_UUID))
		}
		socket.connect()

		val connectionResponse =
		mBumble
		.rfcommBlocking()
		.withDeadlineAfter(GRPC_TIMEOUT.toMillis(), TimeUnit.MILLISECONDS)
		.acceptConnection(
		RfcommProto.AcceptConnectionRequest.newBuilder().setServer(server).build()
		)
		Truth.assertThat(connectionResponse.connection.id).isEqualTo(mConnectionCounter)
		Truth.assertThat(socket.isConnected).isTrue()

		mConnectionCounter += 1
		val connection = connectionResponse.connection
		return Pair(socket, connection)
		}

		@OptIn(ExperimentalCoroutinesApi::class)
		private suspend fun bondDevice(remoteDevice: BluetoothDevice) {
		if (mAdapter.bondedDevices.contains(remoteDevice)) {
		Log.d(TAG, "bondDevice(): The device is already bonded")
		return
		}

		val flow = bondingFlow(mContext, remoteDevice, BluetoothDevice.BOND_BONDED)

		Truth.assertThat(remoteDevice.createBond()).isTrue()

		flow.first()
		}

		@OptIn(ExperimentalCoroutinesApi::class)
		private suspend fun removeBondIfBonded(deviceToRemove: BluetoothDevice) {
		if (!mAdapter.bondedDevices.contains(deviceToRemove)) {
		Log.d(TAG, "removeBondIfBonded(): Tried to remove a device that isn't bonded")
		return
		}
		val flow = bondingFlow(mContext, deviceToRemove, BluetoothDevice.BOND_NONE)

		Truth.assertThat(deviceToRemove.removeBond()).isTrue()

		flow.first()
		}

		private fun startServer(block: (ServerId) -> Unit) {
		val request =
		StartServerRequest.newBuilder().setName(TEST_SERVER_NAME).setUuid(TEST_UUID).build()
		val response = mBumble.rfcommBlocking().startServer(request)

		try {
		block(response.server)
		} finally {
		mBumble
		.rfcommBlocking()
		.withDeadlineAfter(GRPC_TIMEOUT.toMillis(), TimeUnit.MILLISECONDS)
		.stopServer(
		RfcommProto.StopServerRequest.newBuilder().setServer(response.server).build()
		)
		runBlocking { removeBondIfBonded(mBumbleDevice) }
		}
		}

		companion object {
		private val TAG = RfcommTest::class.java.getSimpleName()
		private val GRPC_TIMEOUT = Duration.ofSeconds(10)
		private val BOND_TIMEOUT = Duration.ofSeconds(20)
		private const val TEST_UUID = "00001101-0000-1000-8000-00805F9B34FB"
		private const val TEST_SERVER_NAME = "RFCOMM Server"
		}
		}

framework/tests/bumble/src/bumble_server.py

+4 −0

Original line number	Diff line number	Diff line
		@@ -23,10 +23,12 @@ from bumble.pandora import PandoraDevice, Config, serve
		from bumble_experimental.asha import AshaService
		from bumble_experimental.dck import DckService
		from bumble_experimental.gatt import GATTService
		from bumble_experimental.rfcomm import RFCOMMService

		from pandora_experimental.asha_grpc_aio import add_AshaServicer_to_server
		from pandora_experimental.dck_grpc_aio import add_DckServicer_to_server
		from pandora_experimental.gatt_grpc_aio import add_GATTServicer_to_server
		from pandora_experimental.rfcomm_grpc_aio import add_RFCOMMServicer_to_server

		from typing import Dict, Any

		@@ -73,6 +75,8 @@ def register_experimental_services():
		lambda bumble, _, server: add_DckServicer_to_server(DckService(bumble.device), server))
		bumble_server.register_servicer_hook(
		lambda bumble, _, server: add_GATTServicer_to_server(GATTService(bumble.device), server))
		bumble_server.register_servicer_hook(
		lambda bumble, _, server: add_RFCOMMServicer_to_server(RFCOMMService(bumble.device), server))


		def retrieve_config(config: str) -> Dict[str, Any]:

pandora/server/bumble_experimental/rfcomm.py

0 → 100644

+108 −0

Original line number	Diff line number	Diff line
		# Copyright (C) 2024 The Android Open Source Project
		# 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
		#
		# Unless required by applicable law or agreed to in writing, software
		# distributed under the License is distributed on an "AS IS" BASIS,
		# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		# See the License for the specific language governing permissions and
		# limitations under the License.

		import asyncio
		import logging
		from typing import Dict, Optional

		from bumble import core
		from bumble.device import Device
		from bumble.rfcomm import (
		Server,
		make_service_sdp_records,
		DLC,
		)
		from bumble.pandora import utils
		import grpc
		from pandora_experimental.rfcomm_grpc_aio import RFCOMMServicer
		from pandora_experimental.rfcomm_pb2 import (
		AcceptConnectionRequest,
		AcceptConnectionResponse,
		ConnectionRequest,
		ConnectionResponse,
		RfcommConnection,
		RxRequest,
		RxResponse,
		ServerId,
		StartServerRequest,
		StartServerResponse,
		StopServerRequest,
		StopServerResponse,
		TxRequest,
		TxResponse,
		)


		class RFCOMMService(RFCOMMServicer):
		#TODO Add support for multiple servers
		device: Device
		server_id: Optional[ServerId]
		server: Optional[Server]

		def __init__(self, device: Device) -> None:
		super().__init__()
		self.device = device
		self.server_id = None
		self.server = None
		self.server_name = None
		self.server_uuid = None
		self.connections = {} # key = id, value = dlc
		self.next_server_id = 1
		self.next_conn_id = 1
		self.open_channel = None
		self.wait_dlc = None
		self.dlc = None
		self.data_queue = asyncio.Queue()

		@utils.rpc
		async def StartServer(self, request: StartServerRequest, context: grpc.ServicerContext) -> StartServerResponse:
		logging.info(f"StartServer")
		if self.server_id:
		logging.warning(f"Server already started, returning existing server")
		return StartServerResponse(server=self.server_id)
		else:
		self.server_id = ServerId(id=self.next_server_id)
		self.next_server_id += 1
		self.server = Server(self.device)
		self.server_name = request.name
		self.server_uuid = core.UUID(request.uuid)
		self.wait_dlc = asyncio.get_running_loop().create_future()
		handle = 1
		#TODO Add support for multiple clients
		self.open_channel = self.server.listen(acceptor=self.wait_dlc.set_result, channel=2)
		records = make_service_sdp_records(handle, self.open_channel, self.server_uuid)
		self.device.sdp_service_records[handle] = records
		return StartServerResponse(server=self.server_id)

		@utils.rpc
		async def AcceptConnection(self, request: AcceptConnectionRequest,
		context: grpc.ServicerContext) -> AcceptConnectionResponse:
		logging.info(f"AcceptConnection")
		assert self.server_id.id == request.server.id
		self.dlc = await self.wait_dlc
		self.dlc.sink = self.data_queue.put_nowait
		new_conn = RfcommConnection(id=self.next_conn_id)
		self.next_conn_id += 1
		self.connections[new_conn.id] = self.dlc
		return AcceptConnectionResponse(connection=new_conn)

		@utils.rpc
		async def StopServer(self, request: StopServerRequest, context: grpc.ServicerContext) -> StopServerResponse:
		logging.info(f"StopServer")
		assert self.server_id.id == request.server.id
		self.server = None
		self.server_id = None
		self.server_name = None
		self.server_uuid = None

		return StopServerResponse()