Merge changes I5c6660cf,I0d23f257,I82f2cd18 (e4063eb3) · Commits · e / os / android_packages_modules_Bluetooth

system/gd/rust/linux/client/src/callbacks.rs

+14 −18

Original line number	Original line	Diff line number	Diff line
	use crate::dbus_iface::{		use crate::dbus_iface::{
	export_bluetooth_callback_dbus_obj, export_bluetooth_connection_callback_dbus_obj,		export_bluetooth_callback_dbus_intf, export_bluetooth_connection_callback_dbus_intf,
	export_bluetooth_gatt_callback_dbus_obj, export_bluetooth_manager_callback_dbus_obj,		export_bluetooth_gatt_callback_dbus_intf, export_bluetooth_manager_callback_dbus_intf,
	export_suspend_callback_dbus_obj,		export_suspend_callback_dbus_intf,
	};		};
	use crate::ClientContext;		use crate::ClientContext;
	use crate::{console_yellow, print_info};		use crate::{console_yellow, print_info};
	@@ -70,13 +70,12 @@ impl RPCProxy for BtManagerCallback {

	fn export_for_rpc(self: Box<Self>) {		fn export_for_rpc(self: Box<Self>) {
	let cr = self.dbus_crossroads.clone();		let cr = self.dbus_crossroads.clone();
	export_bluetooth_manager_callback_dbus_obj(		let iface = export_bluetooth_manager_callback_dbus_intf(
	self.get_object_id(),
	self.dbus_connection.clone(),		self.dbus_connection.clone(),
	&mut cr.lock().unwrap(),		&mut cr.lock().unwrap(),
	Arc::new(Mutex::new(self)),
	Arc::new(Mutex::new(DisconnectWatcher::new())),		Arc::new(Mutex::new(DisconnectWatcher::new())),
	);		);
			cr.lock().unwrap().insert(self.get_object_id(), &[iface], Arc::new(Mutex::new(self)));
	}		}
	}		}

	@@ -232,13 +231,12 @@ impl RPCProxy for BtCallback {

	fn export_for_rpc(self: Box<Self>) {		fn export_for_rpc(self: Box<Self>) {
	let cr = self.dbus_crossroads.clone();		let cr = self.dbus_crossroads.clone();
	export_bluetooth_callback_dbus_obj(		let iface = export_bluetooth_callback_dbus_intf(
	self.get_object_id(),
	self.dbus_connection.clone(),		self.dbus_connection.clone(),
	&mut cr.lock().unwrap(),		&mut cr.lock().unwrap(),
	Arc::new(Mutex::new(self)),
	Arc::new(Mutex::new(DisconnectWatcher::new())),		Arc::new(Mutex::new(DisconnectWatcher::new())),
	);		);
			cr.lock().unwrap().insert(self.get_object_id(), &[iface], Arc::new(Mutex::new(self)));
	}		}
	}		}

	@@ -286,13 +284,12 @@ impl RPCProxy for BtConnectionCallback {

	fn export_for_rpc(self: Box<Self>) {		fn export_for_rpc(self: Box<Self>) {
	let cr = self.dbus_crossroads.clone();		let cr = self.dbus_crossroads.clone();
	export_bluetooth_connection_callback_dbus_obj(		let iface = export_bluetooth_connection_callback_dbus_intf(
	self.get_object_id(),
	self.dbus_connection.clone(),		self.dbus_connection.clone(),
	&mut cr.lock().unwrap(),		&mut cr.lock().unwrap(),
	Arc::new(Mutex::new(self)),
	Arc::new(Mutex::new(DisconnectWatcher::new())),		Arc::new(Mutex::new(DisconnectWatcher::new())),
	);		);
			cr.lock().unwrap().insert(self.get_object_id(), &[iface], Arc::new(Mutex::new(self)));
	}		}
	}		}

	@@ -458,13 +455,13 @@ impl RPCProxy for BtGattCallback {

	fn export_for_rpc(self: Box<Self>) {		fn export_for_rpc(self: Box<Self>) {
	let cr = self.dbus_crossroads.clone();		let cr = self.dbus_crossroads.clone();
	export_bluetooth_gatt_callback_dbus_obj(		let iface = export_bluetooth_gatt_callback_dbus_intf(
	self.get_object_id(),
	self.dbus_connection.clone(),		self.dbus_connection.clone(),
	&mut cr.lock().unwrap(),		&mut cr.lock().unwrap(),
	Arc::new(Mutex::new(self)),
	Arc::new(Mutex::new(DisconnectWatcher::new())),		Arc::new(Mutex::new(DisconnectWatcher::new())),
	);		);

			cr.lock().unwrap().insert(self.get_object_id(), &[iface], Arc::new(Mutex::new(self)));
	}		}
	}		}

	@@ -508,12 +505,11 @@ impl RPCProxy for SuspendCallback {

	fn export_for_rpc(self: Box<Self>) {		fn export_for_rpc(self: Box<Self>) {
	let cr = self.dbus_crossroads.clone();		let cr = self.dbus_crossroads.clone();
	export_suspend_callback_dbus_obj(		let iface = export_suspend_callback_dbus_intf(
	self.get_object_id(),
	self.dbus_connection.clone(),		self.dbus_connection.clone(),
	&mut cr.lock().unwrap(),		&mut cr.lock().unwrap(),
	Arc::new(Mutex::new(self)),
	Arc::new(Mutex::new(DisconnectWatcher::new())),		Arc::new(Mutex::new(DisconnectWatcher::new())),
	);		);
			cr.lock().unwrap().insert(self.get_object_id(), &[iface], Arc::new(Mutex::new(self)));
	}		}
	}		}

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

+6 −6

Original line number	Original line	Diff line number	Diff line
	@@ -120,7 +120,7 @@ impl RPCProxy for IBluetoothCallbackDBus {
	}		}

	#[generate_dbus_exporter(		#[generate_dbus_exporter(
	export_bluetooth_callback_dbus_obj,		export_bluetooth_callback_dbus_intf,
	"org.chromium.bluetooth.BluetoothCallback"		"org.chromium.bluetooth.BluetoothCallback"
	)]		)]
	impl IBluetoothCallback for IBluetoothCallbackDBus {		impl IBluetoothCallback for IBluetoothCallbackDBus {
	@@ -177,7 +177,7 @@ impl RPCProxy for IBluetoothConnectionCallbackDBus {
	}		}

	#[generate_dbus_exporter(		#[generate_dbus_exporter(
	export_bluetooth_connection_callback_dbus_obj,		export_bluetooth_connection_callback_dbus_intf,
	"org.chromium.bluetooth.BluetoothConnectionCallback"		"org.chromium.bluetooth.BluetoothConnectionCallback"
	)]		)]
	impl IBluetoothConnectionCallback for IBluetoothConnectionCallbackDBus {		impl IBluetoothConnectionCallback for IBluetoothConnectionCallbackDBus {
	@@ -519,7 +519,7 @@ impl RPCProxy for IBluetoothManagerCallbackDBus {
	}		}

	#[generate_dbus_exporter(		#[generate_dbus_exporter(
	export_bluetooth_manager_callback_dbus_obj,		export_bluetooth_manager_callback_dbus_intf,
	"org.chromium.bluetooth.ManagerCallback"		"org.chromium.bluetooth.ManagerCallback"
	)]		)]
	impl IBluetoothManagerCallback for IBluetoothManagerCallbackDBus {		impl IBluetoothManagerCallback for IBluetoothManagerCallbackDBus {
	@@ -737,7 +737,7 @@ impl RPCProxy for IBluetoothGattCallbackDBus {
	}		}

	#[generate_dbus_exporter(		#[generate_dbus_exporter(
	export_bluetooth_gatt_callback_dbus_obj,		export_bluetooth_gatt_callback_dbus_intf,
	"org.chromium.bluetooth.BluetoothGattCallback"		"org.chromium.bluetooth.BluetoothGattCallback"
	)]		)]
	impl IBluetoothGattCallback for IBluetoothGattCallbackDBus {		impl IBluetoothGattCallback for IBluetoothGattCallbackDBus {
	@@ -812,7 +812,7 @@ impl SuspendDBus {
	client_proxy: ClientDBusProxy::new(		client_proxy: ClientDBusProxy::new(
	conn.clone(),		conn.clone(),
	String::from("org.chromium.bluetooth"),		String::from("org.chromium.bluetooth"),
	make_object_path(index, "suspend"),		make_object_path(index, "adapter"),
	String::from("org.chromium.bluetooth.Suspend"),		String::from("org.chromium.bluetooth.Suspend"),
	),		),
	}		}
	@@ -860,7 +860,7 @@ impl RPCProxy for ISuspendCallbackDBus {
	}		}

	#[generate_dbus_exporter(		#[generate_dbus_exporter(
	export_suspend_callback_dbus_obj,		export_suspend_callback_dbus_intf,
	"org.chromium.bluetooth.SuspendCallback"		"org.chromium.bluetooth.SuspendCallback"
	)]		)]
	impl ISuspendCallback for ISuspendCallbackDBus {		impl ISuspendCallback for ISuspendCallbackDBus {

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

+167 −25

Original line number	Original line	Diff line number	Diff line
	@@ -42,13 +42,28 @@ pub fn dbus_method(_attr: TokenStream, item: TokenStream) -> TokenStream {
	gen.into()		gen.into()
	}		}

	/// Generates a function to export a Rust object to D-Bus.		/// Generates a function to export a Rust object to D-Bus. The result will provide an IFaceToken
			/// that must then be registered to an object.
	///		///
	/// Example:		/// Example:
	/// `#[generate_dbus_exporter(export_foo_dbus_obj, "org.example.FooInterface")]`		/// `#[generate_dbus_exporter(export_foo_dbus_intf, "org.example.FooInterface")]`
			/// `#[generate_dbus_exporter(export_foo_dbus_intf, "org.example.FooInterface", FooMixin, foo]`
	///		///
	/// This generates a method called `export_foo_dbus_obj` that will export a Rust object into a		/// This generates a method called `export_foo_dbus_intf` that will export a Rust object type into a
	/// D-Bus object having interface `org.example.FooInterface`.		/// interface token for `org.example.FooInterface`. This interface must then be inserted to an
			/// object in order to be exported.
			///
			/// If the mixin parameter is provided, you must provide the mixin class when registering with
			/// crossroads (and that's the one that should be Arc<Mutex<...>>.
			///
			/// # Args
			///
			/// `exporter`: Function name for outputted interface exporter.
			/// `interface`: Name of the interface where this object should be exported.
			/// `mixin_type`: The name of the Mixin struct. Mixins should be used when
			/// exporting multiple interfaces and objects under a single object
			/// path.
			/// `mixin`: Name of this object in the mixin where it's implemented.
	#[proc_macro_attribute]		#[proc_macro_attribute]
	pub fn generate_dbus_exporter(attr: TokenStream, item: TokenStream) -> TokenStream {		pub fn generate_dbus_exporter(attr: TokenStream, item: TokenStream) -> TokenStream {
	let ori_item: proc_macro2::TokenStream = item.clone().into();		let ori_item: proc_macro2::TokenStream = item.clone().into();
	@@ -67,12 +82,28 @@ pub fn generate_dbus_exporter(attr: TokenStream, item: TokenStream) -> TokenStre
	panic!("D-Bus interface name must be specified");		panic!("D-Bus interface name must be specified");
	};		};

			// Must provide both a mixin type and name.
			let (mixin_type, mixin_name) = if args.len() > 3 {
			match (&args[2], &args[3]) {
			(Expr::Path(t), Expr::Path(n)) => (Some(t), Some(n)),
			(_, _) => (None, None),
			}
			} else {
			(None, None)
			};

	let ast: ItemImpl = syn::parse(item.clone()).unwrap();		let ast: ItemImpl = syn::parse(item.clone()).unwrap();
	let api_iface_ident = ast.trait_.unwrap().1.to_token_stream();		let api_iface_ident = ast.trait_.unwrap().1.to_token_stream();

	let mut register_methods = quote! {};		let mut register_methods = quote! {};

	let obj_type = quote! { std::sync::Arc<std::sync::Mutex<Box<T>>> };		// If the object isn't expected to be part of a mixin, expect the object
			// type to be Arc<Mutex<Box<T>>>. Otherwise, we accept any type T and depend
			// on the field name lookup to throw an error.
			let obj_type = match mixin_type {
			None => quote! { std::sync::Arc<std::sync::Mutex<Box<T>>> },
			Some(t) => quote! { Box<#t> },
			};

	for item in ast.items {		for item in ast.items {
	if let ImplItem::Method(method) = item {		if let ImplItem::Method(method) = item {
	@@ -165,6 +196,19 @@ pub fn generate_dbus_exporter(attr: TokenStream, item: TokenStream) -> TokenStre
	output_names = quote! { "out", };		output_names = quote! { "out", };
	}		}

			let method_call = match mixin_name {
			Some(name) => {
			quote! {
			let ret = obj.#name.lock().unwrap().#method_name(#method_args);
			}
			}
			None => {
			quote! {
			let ret = obj.lock().unwrap().#method_name(#method_args);
			}
			}
			};

	register_methods = quote! {		register_methods = quote! {
	#register_methods		#register_methods

	@@ -175,7 +219,7 @@ pub fn generate_dbus_exporter(attr: TokenStream, item: TokenStream) -> TokenStre
	#dbus_input_args \|		#dbus_input_args \|
	-> Result<(#output_type), dbus_crossroads::MethodErr> {		-> Result<(#output_type), dbus_crossroads::MethodErr> {
	#make_args		#make_args
	let ret = obj.lock().unwrap().#method_name(#method_args);		#method_call
	#ret		#ret
	};		};
	ibuilder.method(		ibuilder.method(
	@@ -188,17 +232,16 @@ pub fn generate_dbus_exporter(attr: TokenStream, item: TokenStream) -> TokenStre
	}		}
	}		}

			// If mixin is not given, we enforce the API trait is implemented when exporting.
			let type_t = match mixin_type {
			None => quote! { <T: 'static + #api_iface_ident + Send + ?Sized> },
			Some(_) => quote! {},
			};

	let gen = quote! {		let gen = quote! {
	#ori_item		#ori_item

	pub fn #fn_ident<T: 'static + #api_iface_ident + Send + ?Sized, P: Into<dbus::Path<'static>>>(		pub fn #fn_ident #type_t(
	path: P,
	conn: std::sync::Arc<dbus::nonblock::SyncConnection>,
	cr: &mut dbus_crossroads::Crossroads,
	obj: #obj_type,
	disconnect_watcher: std::sync::Arc<std::sync::Mutex<dbus_projection::DisconnectWatcher>>,
	) {
	fn get_iface_token<T: #api_iface_ident + Send + ?Sized>(
	conn: std::sync::Arc<dbus::nonblock::SyncConnection>,		conn: std::sync::Arc<dbus::nonblock::SyncConnection>,
	cr: &mut dbus_crossroads::Crossroads,		cr: &mut dbus_crossroads::Crossroads,
	disconnect_watcher: std::sync::Arc<std::sync::Mutex<dbus_projection::DisconnectWatcher>>,		disconnect_watcher: std::sync::Arc<std::sync::Mutex<dbus_projection::DisconnectWatcher>>,
	@@ -207,10 +250,6 @@ pub fn generate_dbus_exporter(attr: TokenStream, item: TokenStream) -> TokenStre
	#register_methods		#register_methods
	})		})
	}		}

	let iface_token = get_iface_token(conn, cr, disconnect_watcher);
	cr.insert(path, &[iface_token], obj);
	}
	};		};

	debug_output_to_file(&gen, format!("out-{}.rs", fn_ident.to_string()));		debug_output_to_file(&gen, format!("out-{}.rs", fn_ident.to_string()));
	@@ -768,7 +807,7 @@ pub fn dbus_proxy_obj(attr: TokenStream, item: TokenStream) -> TokenStream {
	#[proc_macro]		#[proc_macro]
	pub fn generate_dbus_arg(_item: TokenStream) -> TokenStream {		pub fn generate_dbus_arg(_item: TokenStream) -> TokenStream {
	let gen = quote! {		let gen = quote! {
	use dbus::arg::PropMap;		use dbus::arg::{PropMap, RefArg};
	use dbus::nonblock::SyncConnection;		use dbus::nonblock::SyncConnection;
	use dbus::strings::BusName;		use dbus::strings::BusName;
	use dbus_projection::DisconnectWatcher;		use dbus_projection::DisconnectWatcher;
	@@ -777,6 +816,9 @@ pub fn generate_dbus_arg(_item: TokenStream) -> TokenStream {
	use std::fmt;		use std::fmt;
	use std::sync::{Arc, Mutex};		use std::sync::{Arc, Mutex};

			// Key for serialized Option<T> in propmap
			const OPTION_KEY: &'static str = "optional_value";

	#[derive(Debug)]		#[derive(Debug)]
	pub(crate) struct DBusArgError {		pub(crate) struct DBusArgError {
	message: String,		message: String,
	@@ -804,7 +846,7 @@ pub fn generate_dbus_arg(_item: TokenStream) -> TokenStream {
	) -> Result<Self::RustType, Box<dyn Error>>;		) -> Result<Self::RustType, Box<dyn Error>>;
	}		}

	impl<T: 'static + Clone + DirectDBus> RefArgToRust for T {		impl<T: 'static + DirectDBus> RefArgToRust for T {
	type RustType = T;		type RustType = T;
	fn ref_arg_to_rust(		fn ref_arg_to_rust(
	arg: &(dyn dbus::arg::RefArg + 'static),		arg: &(dyn dbus::arg::RefArg + 'static),
	@@ -824,6 +866,31 @@ pub fn generate_dbus_arg(_item: TokenStream) -> TokenStream {
	}		}
	}		}

			impl RefArgToRust for std::fs::File {
			type RustType = std::fs::File;

			fn ref_arg_to_rust(
			arg: &(dyn dbus::arg::RefArg + 'static),
			name: String,
			) -> Result<Self::RustType, Box<dyn Error>> {
			let any = arg.as_any();
			if !any.is::<<Self as DBusArg>::DBusType>() {
			return Err(Box::new(DBusArgError::new(String::from(format!(
			"{} type does not match: expected {}, found {}",
			name,
			std::any::type_name::<<Self as DBusArg>::DBusType>(),
			arg.arg_type().as_str(),
			)))));
			}
			let arg = match (*any.downcast_ref::<<Self as DBusArg>::DBusType>().unwrap()).try_clone() {
			Ok(foo) => foo,
			Err(_) => return Err(Box::new(DBusArgError::new(String::from(format!("{} cannot clone file.", name))))),
			};

			return Ok(arg);
			}
			}

	impl RefArgToRust for dbus::arg::PropMap {		impl RefArgToRust for dbus::arg::PropMap {
	type RustType = dbus::arg::PropMap;		type RustType = dbus::arg::PropMap;
	fn ref_arg_to_rust(		fn ref_arg_to_rust(
	@@ -890,7 +957,7 @@ pub fn generate_dbus_arg(_item: TokenStream) -> TokenStream {
	}		}

	// Types that implement dbus::arg::Append do not need any conversion.		// Types that implement dbus::arg::Append do not need any conversion.
	pub(crate) trait DirectDBus {}		pub(crate) trait DirectDBus: Clone {}
	impl DirectDBus for bool {}		impl DirectDBus for bool {}
	impl DirectDBus for i32 {}		impl DirectDBus for i32 {}
	impl DirectDBus for u32 {}		impl DirectDBus for u32 {}
	@@ -916,6 +983,23 @@ pub fn generate_dbus_arg(_item: TokenStream) -> TokenStream {
	}		}
	}		}

			impl DBusArg for std::fs::File {
			type DBusType = std::fs::File;

			fn from_dbus(
			data: std::fs::File,
			_conn: Option<Arc<dbus::nonblock::SyncConnection>>,
			_remote: Option<BusName<'static>>,
			_disconnect_watcher: Option<Arc<Mutex<DisconnectWatcher>>>,
			) -> Result<std::fs::File, Box<dyn Error>> {
			return Ok(data);
			}

			fn to_dbus(data: std::fs::File) -> Result<std::fs::File, Box<dyn Error>> {
			return Ok(data);
			}
			}

	impl<T: DBusArg> DBusArg for Vec<T> {		impl<T: DBusArg> DBusArg for Vec<T> {
	type DBusType = Vec<T::DBusType>;		type DBusType = Vec<T::DBusType>;

	@@ -947,6 +1031,64 @@ pub fn generate_dbus_arg(_item: TokenStream) -> TokenStream {
	Ok(list)		Ok(list)
	}		}
	}		}

			impl<T: DBusArg> DBusArg for Option<T>
			where <T as DBusArg>::DBusType: dbus::arg::RefArg + 'static + RefArgToRust<RustType = <T as DBusArg>::DBusType> {
			type DBusType = dbus::arg::PropMap;

			fn from_dbus(
			data: dbus::arg::PropMap,
			conn: Option<Arc<dbus::nonblock::SyncConnection>>,
			remote: Option<BusName<'static>>,
			disconnect_watcher: Option<Arc<Mutex<DisconnectWatcher>>>)
			-> Result<Option<T>, Box<dyn Error>> {
			let mut result: Option<T> = None;

			// It's Ok if the key doesn't exist. That just means we have an empty option (i.e.
			// None).
			let prop_value = match data.get(OPTION_KEY) {
			Some(data) => data,
			None => {
			return Ok(None);
			}
			};

			// Make sure the option type was encoded correctly. If the key exists but the value
			// is not right, we return an Err type.
			match prop_value.arg_type() {
			dbus::arg::ArgType::Variant => (),
			_ => {
			return Err(Box::new(DBusArgError::new(String::from(format!("{} must be a variant", OPTION_KEY)))));
			}
			};

			// Convert the Variant into the target type and return an Err if that fails.
			let ref_value: <T as DBusArg>::DBusType = match <<T as DBusArg>::DBusType as RefArgToRust>::ref_arg_to_rust(
			prop_value.as_static_inner(0).unwrap(),
			OPTION_KEY.to_string()) {
			Ok(v) => v,
			Err(e) => return Err(e),
			};

			let value = match T::from_dbus(ref_value, conn, remote, disconnect_watcher) {
			Ok(v) => Some(v),
			Err(_) => None,
			};

			Ok(value)
			}

			fn to_dbus(data: Option<T>) -> Result<dbus::arg::PropMap, Box<dyn Error>> {
			let mut props = dbus::arg::PropMap::new();

			if let Some(d) = data {
			let b = T::to_dbus(d)?;
			props.insert(OPTION_KEY.to_string(), dbus::arg::Variant(Box::new(b)));
			}

			Ok(props)
			}
			}
	};		};

	debug_output_to_file(&gen, format!("out-generate_dbus_arg.rs"));		debug_output_to_file(&gen, format!("out-generate_dbus_arg.rs"));

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

+4 −4

Original line number	Original line	Diff line number	Diff line
	@@ -291,9 +291,9 @@ macro_rules! impl_dbus_arg_from_into {
	Arc<std::sync::Mutex<dbus_projection::DisconnectWatcher>>,		Arc<std::sync::Mutex<dbus_projection::DisconnectWatcher>>,
	>,		>,
	) -> Result<$rust_type, Box<dyn std::error::Error>> {		) -> Result<$rust_type, Box<dyn std::error::Error>> {
	match <$rust_type>::try_from(data) {		match <$rust_type>::try_from(data.clone()) {
	Err(e) => Err(Box::new(DBusArgError::new(String::from(format!(		Err(e) => Err(Box::new(DBusArgError::new(String::from(format!(
	"error converting {} to {}",		"error converting {:?} to {:?}",
	data,		data,
	stringify!($rust_type),		stringify!($rust_type),
	))))),		))))),
	@@ -302,9 +302,9 @@ macro_rules! impl_dbus_arg_from_into {
	}		}

	fn to_dbus(data: $rust_type) -> Result<$dbus_type, Box<dyn std::error::Error>> {		fn to_dbus(data: $rust_type) -> Result<$dbus_type, Box<dyn std::error::Error>> {
	match data.try_into() {		match data.clone().try_into() {
	Err(e) => Err(Box::new(DBusArgError::new(String::from(format!(		Err(e) => Err(Box::new(DBusArgError::new(String::from(format!(
	"error converting {:?} to {}",		"error converting {:?} to {:?}",
	data,		data,
	stringify!($dbus_type)		stringify!($dbus_type)
	))))),		))))),

system/gd/rust/linux/dbus_projection/tests/conversions.rs

+1 −1

Original line number	Original line	Diff line number	Diff line
	@@ -2,7 +2,7 @@ use core::any::Any;

	use dbus_macros::{dbus_propmap, generate_dbus_arg};		use dbus_macros::{dbus_propmap, generate_dbus_arg};

	use dbus::arg::{Arg, ArgType, IterAppend, RefArg};		use dbus::arg::{Arg, ArgType, IterAppend};
	use dbus::Signature;		use dbus::Signature;

	generate_dbus_arg!();		generate_dbus_arg!();