Merge "Floss: Fix deadlock between btmanagerd and btadapterd" (1dbd7753) · Commits · e / os / android_packages_modules_Bluetooth

system/gd/rust/linux/dbus_projection/dbus_macros/src/lib.rs

+7 −8

Original line number	Diff line number	Diff line
		@@ -373,22 +373,21 @@ pub fn generate_dbus_interface_client(attr: TokenStream, item: TokenStream) -> T
		path
		};
		};

		input_list = quote! {
		#input_list
		#ident,
		};
		} else {
		// Convert every parameter to its corresponding type recognized by
		// the D-Bus library.
		object_conversions = quote! {
		#object_conversions
		let #ident = <#arg_type as DBusArg>::to_dbus(#ident).unwrap();
		};
		}
		input_list = quote! {
		#input_list
		<#arg_type as DBusArg>::to_dbus(#ident).unwrap(),
		#ident,
		};
		}
		}
		}
		}

		let mut output_as_dbus_arg = quote! {};
		if let ReturnType::Type(_, t) = &method.sig.output {

system/gd/rust/linux/dbus_projection/src/lib.rs

+1 −0

Original line number	Diff line number	Diff line
		@@ -154,6 +154,7 @@ impl DisconnectWatcher {

		/// A client proxy to conveniently call API methods generated with the
		/// [`generate_dbus_interface_client`](dbus_macros::generate_dbus_interface_client) macro.
		#[derive(Clone)]
		pub struct ClientDBusProxy {
		conn: Arc<SyncConnection>,
		bus_name: String,

system/gd/rust/linux/mgmt/src/dbus_iface.rs

+20 −7

Original line number	Diff line number	Diff line
		@@ -12,24 +12,37 @@ use crate::dbus_arg::{DBusArg, DBusArgError};

		impl_dbus_arg_enum!(SuspendType);

		#[derive(Clone)]
		pub struct SuspendDBusRPC {
		client_proxy: ClientDBusProxy,
		}

		pub struct SuspendDBus {
		client_proxy: ClientDBusProxy,
		pub rpc: SuspendDBusRPC,
		}

		impl SuspendDBus {
		pub(crate) fn new(conn: Arc<SyncConnection>, path: dbus::Path<'static>) -> SuspendDBus {
		SuspendDBus {
		client_proxy: ClientDBusProxy::new(
		fn make_client_proxy(conn: Arc<SyncConnection>, path: dbus::Path<'static>) -> ClientDBusProxy {
		ClientDBusProxy::new(
		conn.clone(),
		String::from("org.chromium.bluetooth"),
		path,
		String::from("org.chromium.bluetooth.Suspend"),
		),
		)
		}

		pub(crate) fn new(conn: Arc<SyncConnection>, path: dbus::Path<'static>) -> SuspendDBus {
		SuspendDBus {
		client_proxy: Self::make_client_proxy(conn.clone(), path.clone()),
		rpc: SuspendDBusRPC {
		client_proxy: Self::make_client_proxy(conn.clone(), path.clone()),
		},
		}
		}
		}

		#[generate_dbus_interface_client]
		#[generate_dbus_interface_client(SuspendDBusRPC)]
		impl ISuspend for SuspendDBus {
		#[dbus_method("RegisterCallback")]
		fn register_callback(&mut self, callback: Box<dyn ISuspendCallback + Send>) -> bool {

system/gd/rust/linux/mgmt/src/powerd_suspend_manager.rs

+32 −15

Original line number	Diff line number	Diff line
		use btstack::suspend::{ISuspend, ISuspendCallback, SuspendType};
		use btstack::suspend::{ISuspendCallback, SuspendType};
		use btstack::RPCProxy;
		use dbus::channel::MatchingReceiver;
		use dbus::message::MatchRule;
		@@ -443,10 +443,17 @@ impl PowerdSuspendManager {
		// times in the `if let` block below. Prevent deadlock by locking only once.
		let mut context_locked = self.context.lock().unwrap();
		if let Some(adapter_suspend_dbus) = &mut context_locked.adapter_suspend_dbus {
		adapter_suspend_dbus.suspend(match suspend_imminent.get_reason() {
		let mut suspend_dbus_rpc = adapter_suspend_dbus.rpc.clone();
		tokio::spawn(async move {
		let result = suspend_dbus_rpc
		.suspend(match suspend_imminent.get_reason() {
		SuspendImminent_Reason::IDLE => SuspendType::AllowWakeFromHid,
		SuspendImminent_Reason::LID_CLOSED => SuspendType::NoWakesAllowed,
		SuspendImminent_Reason::OTHER => SuspendType::Other,
		})
		.await;

		log::debug!("Adapter suspend call, success = {}", result.is_ok());
		});
		} else {
		// If there is no adapter, that means Bluetooth is not active and we should always
		@@ -478,8 +485,11 @@ impl PowerdSuspendManager {
		self.context.lock().unwrap().pending_suspend_imminent = None;

		if let Some(adapter_suspend_dbus) = &self.context.lock().unwrap().adapter_suspend_dbus {
		let success = adapter_suspend_dbus.resume();
		log::debug!("Adapter resume is successful = {}", success);
		let suspend_dbus_rpc = adapter_suspend_dbus.rpc.clone();
		tokio::spawn(async move {
		let result = suspend_dbus_rpc.resume().await;
		log::debug!("Adapter resume call, success = {}", result.unwrap_or(false));
		});
		} else {
		log::debug!("Adapter is not available, nothing to resume.");
		}
		@@ -495,14 +505,21 @@ impl PowerdSuspendManager {
		let crossroads = self.context.lock().unwrap().dbus_crossroads.clone();

		if let Some(adapter_suspend_dbus) = &mut self.context.lock().unwrap().adapter_suspend_dbus {
		let mut suspend_dbus_rpc = adapter_suspend_dbus.rpc.clone();
		let context = self.context.clone();
		tokio::spawn(async move {
		let suspend_cb_objpath: String =
		format!("/org/chromium/bluetooth/Manager/suspend_callback");
		adapter_suspend_dbus.register_callback(Box::new(SuspendCallback::new(
		let status = suspend_dbus_rpc
		.register_callback(Box::new(SuspendCallback::new(
		suspend_cb_objpath,
		conn,
		crossroads,
		self.context.clone(),
		)));
		context.clone(),
		)))
		.await;
		log::debug!("Suspend::RegisterCallback success = {}", status.unwrap_or(false));
		});
		}
		}