Merge changes I6a0f12b6,I40942038,I4ce65e27 am: a483b3d007 am: de87cbbc34 (91d6c95c) · Commits · e / os / android_packages_modules_Bluetooth

system/gd/rust/hci/src/lib.rs

+73 −18

Original line number	Diff line number	Diff line
		@@ -7,8 +7,13 @@ pub mod error;
		pub mod facade;

		use bt_hal::HalExports;
		use bt_packets::hci::EventChild::{CommandComplete, CommandStatus};
		use bt_packets::hci::{AclPacket, CommandPacket, EventCode, EventPacket, OpCode};
		use bt_packets::hci::EventChild::{
		CommandComplete, CommandStatus, LeMetaEvent, MaxSlotsChange, PageScanRepetitionModeChange,
		VendorSpecificEvent,
		};
		use bt_packets::hci::{
		AclPacket, CommandPacket, EventCode, EventPacket, LeMetaEventPacket, OpCode, SubeventCode,
		};
		use error::Result;
		use gddi::{module, provides, Stoppable};
		use std::collections::HashMap;
		@@ -32,9 +37,11 @@ module! {
		async fn provide_hci(hal_exports: HalExports, rt: Arc<Runtime>) -> HciExports {
		let (cmd_tx, cmd_rx) = channel::<Command>(10);
		let evt_handlers = Arc::new(Mutex::new(HashMap::new()));
		let le_evt_handlers = Arc::new(Mutex::new(HashMap::new()));

		rt.spawn(dispatch(
		evt_handlers.clone(),
		le_evt_handlers.clone(),
		hal_exports.evt_rx,
		hal_exports.cmd_tx,
		cmd_rx,
		@@ -43,6 +50,7 @@ async fn provide_hci(hal_exports: HalExports, rt: Arc<Runtime>) -> HciExports {
		HciExports {
		cmd_tx,
		evt_handlers,
		le_evt_handlers,
		acl_tx: hal_exports.acl_tx,
		acl_rx: hal_exports.acl_rx,
		}
		@@ -68,6 +76,7 @@ struct PendingCommand {
		pub struct HciExports {
		cmd_tx: Sender<Command>,
		evt_handlers: Arc<Mutex<HashMap<EventCode, Sender<EventPacket>>>>,
		le_evt_handlers: Arc<Mutex<HashMap<SubeventCode, Sender<LeMetaEventPacket>>>>,
		/// Transmit end of a channel used to send ACL data
		pub acl_tx: Sender<AclPacket>,
		/// Receive end of a channel used to receive ACL data
		@@ -95,17 +104,49 @@ impl HciExports {
		}

		/// Indicate interest in specific HCI events
		pub async fn register_event_handler(
		pub async fn register_event_handler(&mut self, code: EventCode, sender: Sender<EventPacket>) {
		assert!(
		self.evt_handlers
		.lock()
		.await
		.insert(code, sender)
		.is_none(),
		"A handler for {:?} is already registered",
		code
		);
		}

		/// Remove interest in specific HCI events
		pub async fn unregister_event_handler(&mut self, code: EventCode) {
		self.evt_handlers.lock().await.remove(&code);
		}

		/// Indicate interest in specific LE events
		pub async fn register_le_event_handler(
		&mut self,
		evt_code: EventCode,
		sender: Sender<EventPacket>,
		code: SubeventCode,
		sender: Sender<LeMetaEventPacket>,
		) {
		self.evt_handlers.lock().await.insert(evt_code, sender);
		assert!(
		self.le_evt_handlers
		.lock()
		.await
		.insert(code, sender)
		.is_none(),
		"A handler for {:?} is already registered",
		code
		);
		}

		/// Remove interest in specific LE events
		pub async fn unregister_le_event_handler(&mut self, code: SubeventCode) {
		self.le_evt_handlers.lock().await.remove(&code);
		}
		}

		async fn dispatch(
		evt_handlers: Arc<Mutex<HashMap<EventCode, Sender<EventPacket>>>>,
		le_evt_handlers: Arc<Mutex<HashMap<SubeventCode, Sender<LeMetaEventPacket>>>>,
		evt_rx: Arc<Mutex<Receiver<EventPacket>>>,
		cmd_tx: Sender<CommandPacket>,
		mut cmd_rx: Receiver<Command>,
		@@ -116,22 +157,36 @@ async fn dispatch(
		Some(evt) = consume(&evt_rx) => {
		match evt.specialize() {
		CommandStatus(evt) => {
		let opcode = *evt.get_command_op_code();
		assert!(pending_cmd.is_some(), "Unexpected status event with opcode {:?}", opcode);
		let pending = pending_cmd.take().unwrap();
		assert!(pending.opcode == opcode, "Waiting for {:?}, got {:?}", pending.opcode, opcode);
		pending.fut.send(evt.into()).unwrap();
		let this_opcode = *evt.get_command_op_code();
		match pending_cmd.take() {
		Some(PendingCommand{opcode, fut}) if opcode == this_opcode => fut.send(evt.into()).unwrap(),
		Some(PendingCommand{opcode, ..}) => panic!("Waiting for {:?}, got {:?}", opcode, this_opcode),
		None => panic!("Unexpected status event with opcode {:?}", this_opcode),
		}
		},
		CommandComplete(evt) => {
		let opcode = *evt.get_command_op_code();
		assert!(pending_cmd.is_some(), "Unexpected complete event with opcode {:?}", opcode);
		let pending = pending_cmd.take().unwrap();
		assert!(pending.opcode == opcode, "Waiting for {:?}, got {:?}", pending.opcode, opcode);
		pending.fut.send(evt.into()).unwrap();
		let this_opcode = *evt.get_command_op_code();
		match pending_cmd.take() {
		Some(PendingCommand{opcode, fut}) if opcode == this_opcode => fut.send(evt.into()).unwrap(),
		Some(PendingCommand{opcode, ..}) => panic!("Waiting for {:?}, got {:?}", opcode, this_opcode),
		None => panic!("Unexpected complete event with opcode {:?}", this_opcode),
		}
		},
		LeMetaEvent(evt) => {
		let code = evt.get_subevent_code();
		match le_evt_handlers.lock().await.get(code) {
		Some(sender) => sender.send(evt).await.unwrap(),
		None => panic!("Unhandled le subevent {:?}", code),
		}
		},
		PageScanRepetitionModeChange(_) => {},
		MaxSlotsChange(_) => {},
		VendorSpecificEvent(_) => {},
		_ => {
		if let Some(sender) = evt_handlers.lock().await.get(evt.get_event_code()) {
		sender.send(evt).await.unwrap();
		let code = evt.get_event_code();
		match evt_handlers.lock().await.get(code) {
		Some(sender) => sender.send(evt).await.unwrap(),
		None => panic!("Unhandled le subevent {:?}", code),
		}
		},
		}