floss: Add battery related API declarations (b196a8a8) · Commits · e / os / android_packages_modules_Bluetooth

system/gd/rust/linux/service/src/iface_battery_manager.rs

0 → 100644

+49 −0

Original line number	Diff line number	Diff line
		use btstack::battery_manager::{Battery, BatteryManager, IBatteryManager, IBatteryManagerCallback};
		use btstack::RPCProxy;
		use dbus::arg::RefArg;
		use dbus::strings::Path;
		use dbus_macros::{dbus_method, dbus_propmap, dbus_proxy_obj, generate_dbus_exporter};
		use dbus_projection::{dbus_generated, DisconnectWatcher};

		use crate::dbus_arg::{DBusArg, DBusArgError, RefArgToRust};

		#[dbus_propmap(Battery)]
		pub struct BatteryDBus {
		percentage: i32,
		source_info: String,
		variant: String,
		}

		struct IBatteryManagerCallbackDBus {}

		#[dbus_proxy_obj(BatteryManagerCallback, "org.chromium.bluetooth.BatteryManagerCallback")]
		impl IBatteryManagerCallback for IBatteryManagerCallbackDBus {
		#[dbus_method("OnBatteryInfoUpdated")]
		fn on_battery_info_updated(&self, remote_address: String, battery: Battery) {
		dbus_generated!()
		}
		}

		struct IBatteryManagerDBus {}

		#[generate_dbus_exporter(export_battery_manager_dbus_intf, "org.chromium.bluetooth.BatteryManager")]
		impl IBatteryManager for IBatteryManagerDBus {
		#[dbus_method("GetBatteryInformation")]
		fn get_battery_information(&self, remote_address: String) -> Battery {
		dbus_generated!()
		}

		#[dbus_method("RegisterBatteryCallback")]
		fn register_battery_callback(
		&mut self,
		remote_address: String,
		battery_manager_callback: Box<dyn IBatteryManagerCallback + Send>,
		) -> i32 {
		dbus_generated!()
		}

		#[dbus_method("UnregisterBatteryCallback")]
		fn unregister_battery_callback(&mut self, callback_id: i32) {
		dbus_generated!()
		}
		}

system/gd/rust/linux/service/src/iface_battery_provider_manager.rs

0 → 100644

+54 −0

Original line number	Diff line number	Diff line
		use btstack::battery_manager::Battery;
		use btstack::battery_provider_manager::{
		BatteryProvider, IBatteryProviderCallback, IBatteryProviderManager,
		};
		use btstack::RPCProxy;
		use dbus::arg::RefArg;
		use dbus::strings::Path;
		use dbus_macros::{dbus_method, dbus_propmap, dbus_proxy_obj, generate_dbus_exporter};
		use dbus_projection::{dbus_generated, DisconnectWatcher};

		use crate::dbus_arg::{DBusArg, DBusArgError, RefArgToRust};

		#[dbus_propmap(BatteryProvider)]
		pub struct BatteryProviderDBus {
		source_info: String,
		remote_address: String,
		}

		struct IBatteryProviderCallbackDBus {}

		#[dbus_proxy_obj(BatteryProviderCallback, "org.chromium.bluetooth.BatteryProviderCallback")]
		impl IBatteryProviderCallback for IBatteryProviderCallbackDBus {
		#[dbus_method("RefreshBatteryInfo")]
		fn refresh_battery_info(&self) {
		dbus_generated!()
		}
		}

		struct IBatteryProviderManagerDBus {}

		#[generate_dbus_exporter(
		export_battery_provider_manager_dbus_intf,
		"org.chromium.bluetooth.BatteryProviderManager"
		)]
		impl IBatteryProviderManager for IBatteryProviderManagerDBus {
		#[dbus_method("RegisterBatteryProvider")]
		fn register_battery_provider(
		&mut self,
		battery_provider: BatteryProvider,
		battery_provider_callback: Box<dyn IBatteryProviderCallback + Send>,
		) -> i32 {
		dbus_generated!()
		}

		#[dbus_method("UnregisterBatteryProvider")]
		fn unregister_battery_provider(&mut self, battery_id: i32) {
		dbus_generated!()
		}

		#[dbus_method("SetBatteryPercentage")]
		fn set_battery_percentage(&mut self, battery_id: i32, battery: Battery) {
		dbus_generated!()
		}
		}

system/gd/rust/linux/service/src/main.rs

+29 −0

Original line number	Diff line number	Diff line
		@@ -12,6 +12,8 @@ use syslog::{BasicLogger, Facility, Formatter3164};

		use bt_topshim::{btif::get_btinterface, topstack};
		use btstack::{
		battery_manager::BatteryManager,
		battery_provider_manager::BatteryProviderManager,
		bluetooth::{get_bt_dispatcher, Bluetooth, IBluetooth},
		bluetooth_gatt::BluetoothGatt,
		bluetooth_media::BluetoothMedia,
		@@ -22,6 +24,8 @@ use btstack::{
		use dbus_projection::DisconnectWatcher;

		mod dbus_arg;
		mod iface_battery_manager;
		mod iface_battery_provider_manager;
		mod iface_bluetooth;
		mod iface_bluetooth_gatt;
		mod iface_bluetooth_media;
		@@ -102,6 +106,8 @@ fn main() -> Result<(), Box<dyn Error>> {
		Arc::new(Mutex::new(Box::new(BluetoothGatt::new(intf.clone(), tx.clone()))));
		let bluetooth_media =
		Arc::new(Mutex::new(Box::new(BluetoothMedia::new(tx.clone(), intf.clone()))));
		let battery_provider_manager = Arc::new(Mutex::new(Box::new(BatteryProviderManager::new())));
		let battery_manager = Arc::new(Mutex::new(Box::new(BatteryManager::new())));
		let bluetooth = Arc::new(Mutex::new(Box::new(Bluetooth::new(
		tx.clone(),
		intf.clone(),
		@@ -206,6 +212,19 @@ fn main() -> Result<(), Box<dyn Error>> {
		disconnect_watcher.clone(),
		);

		let battery_provider_manager_iface =
		iface_battery_provider_manager::export_battery_provider_manager_dbus_intf(
		conn.clone(),
		&mut cr.lock().unwrap(),
		disconnect_watcher.clone(),
		);

		let battery_manager_iface = iface_battery_manager::export_battery_manager_dbus_intf(
		conn.clone(),
		&mut cr.lock().unwrap(),
		disconnect_watcher.clone(),
		);

		// Create mixin object for Bluetooth + Suspend interfaces.
		let mixin = Box::new(iface_bluetooth::BluetoothMixin {
		adapter: bluetooth.clone(),
		@@ -230,6 +249,16 @@ fn main() -> Result<(), Box<dyn Error>> {
		&[media_iface],
		bluetooth_media.clone(),
		);
		cr.lock().unwrap().insert(
		make_object_name(adapter_index, "battery_provider_manager"),
		&[battery_provider_manager_iface],
		battery_provider_manager.clone(),
		);
		cr.lock().unwrap().insert(
		make_object_name(adapter_index, "battery__manager"),
		&[battery_manager_iface],
		battery_manager.clone(),
		);

		// Hold locks and initialize all interfaces. This must be done AFTER DBus is
		// initialized so DBus can properly enforce user policies.

system/gd/rust/linux/stack/src/battery_manager.rs

0 → 100644

+55 −0

Original line number	Diff line number	Diff line
		#[derive(Debug, Clone)]
		pub struct Battery {
		pub percentage: i32,
		pub source_info: String,
		pub variant: String,
		}

		pub struct BatteryManager {}

		impl BatteryManager {
		pub fn new() -> BatteryManager {
		BatteryManager {}
		}
		}

		/// Callback for interacting with the BatteryManager.
		pub trait IBatteryManagerCallback {
		/// Invoked whenever battery information associated with the given remote changes.
		fn on_battery_info_updated(&self, remote_address: String, battery: Battery);
		}

		/// Central point for getting battery information that might be sourced from numerous systems.
		pub trait IBatteryManager {
		/// Registers a callback for interfacing with the BatteryManager and returns a unique
		/// callback_id for future calls.
		fn register_battery_callback(
		&mut self,
		remote_address: String,
		battery_manager_callback: Box<dyn IBatteryManagerCallback + Send>,
		) -> i32;

		/// Unregister a callback.
		fn unregister_battery_callback(&mut self, callback_id: i32);

		/// Returns battery information for the remote, sourced from the highest priority origin.
		fn get_battery_information(&self, remote_address: String) -> Battery;
		}

		impl IBatteryManager for BatteryManager {
		fn register_battery_callback(
		&mut self,
		remote_address: String,
		battery_manager_callback: Box<dyn IBatteryManagerCallback + Send>,
		) -> i32 {
		todo!()
		}

		fn unregister_battery_callback(&mut self, callback_id: i32) {
		todo!()
		}

		fn get_battery_information(&self, remote_address: String) -> Battery {
		todo!()
		}
		}

system/gd/rust/linux/stack/src/battery_provider_manager.rs

0 → 100644

+56 −0

Original line number	Diff line number	Diff line
		use crate::battery_manager::Battery;

		#[derive(Debug, Clone)]
		pub struct BatteryProvider {
		pub source_info: String,
		pub remote_address: String,
		}

		/// Callback for BatteryProvider implementers.
		pub trait IBatteryProviderCallback {
		/// Requests that the BatteryProvider send updated battery information.
		fn refresh_battery_info(&self);
		}

		/// Interface for managing BatteryProvider instances.
		pub trait IBatteryProviderManager {
		/// Registers a BatteryProvider and generates a unique batttery ID for future calls.
		fn register_battery_provider(
		&mut self,
		battery_provider: BatteryProvider,
		battery_provider_callback: Box<dyn IBatteryProviderCallback + Send>,
		) -> i32;

		/// Unregisters a BatteryProvider, potentially removes battery information for the remote
		/// device if there are no other providers.
		fn unregister_battery_provider(&mut self, battery_id: i32);

		/// Updates the battery information for the battery associated with battery_id.
		fn set_battery_percentage(&mut self, battery_id: i32, battery: Battery);
		}

		pub struct BatteryProviderManager {}

		impl BatteryProviderManager {
		pub fn new() -> BatteryProviderManager {
		BatteryProviderManager {}
		}
		}

		impl IBatteryProviderManager for BatteryProviderManager {
		fn register_battery_provider(
		&mut self,
		battery_provider: BatteryProvider,
		battery_provider_callback: Box<dyn IBatteryProviderCallback + Send>,
		) -> i32 {
		todo!()
		}

		fn unregister_battery_provider(&mut self, battery_id: i32) {
		todo!()
		}

		fn set_battery_percentage(&mut self, battery_id: i32, battery: Battery) {
		todo!()
		}
		}