diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..ea8c4bf --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +/target diff --git a/.rustfmt.toml b/.rustfmt.toml new file mode 100644 index 0000000..32a9786 --- /dev/null +++ b/.rustfmt.toml @@ -0,0 +1 @@ +edition = "2018" diff --git a/Cargo.lock b/Cargo.lock new file mode 100644 index 0000000..ac8f3f0 --- /dev/null +++ b/Cargo.lock @@ -0,0 +1,46 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +[[package]] +name = "anyhow" +version = "1.0.28" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d9a60d744a80c30fcb657dfe2c1b22bcb3e814c1a1e3674f32bf5820b570fbff" + +[[package]] +name = "dbus" +version = "0.8.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "38f8875bb7afbc20dec12db09e18af3dcbd672b08592d2932950326a6437c616" +dependencies = [ + "libc", + "libdbus-sys", +] + +[[package]] +name = "libc" +version = "0.2.69" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "99e85c08494b21a9054e7fe1374a732aeadaff3980b6990b94bfd3a70f690005" + +[[package]] +name = "libdbus-sys" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dc12a3bc971424edbbf7edaf6e5740483444db63aa8e23d3751ff12a30f306f0" +dependencies = [ + "pkg-config", +] + +[[package]] +name = "pkg-config" +version = "0.3.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "05da548ad6865900e60eaba7f589cc0783590a92e940c26953ff81ddbab2d677" + +[[package]] +name = "telepathy-padfoot" +version = "0.1.0" +dependencies = [ + "anyhow", + "dbus", +] diff --git a/Cargo.toml b/Cargo.toml new file mode 100644 index 0000000..f9d9a22 --- /dev/null +++ b/Cargo.toml @@ -0,0 +1,11 @@ +[package] +name = "telepathy-padfoot" +version = "0.1.0" +authors = ["Nick Thomas "] +edition = "2018" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] +anyhow = "1.0" +dbus = "0.8.2" diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..23ddbc0 --- /dev/null +++ b/LICENSE @@ -0,0 +1,18 @@ +Copyright 2020 Nick Thomas + +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +the Software, and to permit persons to whom the Software is furnished to do so, +subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS +FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR +COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/README.md b/README.md new file mode 100644 index 0000000..61842ae --- /dev/null +++ b/README.md @@ -0,0 +1,41 @@ +# Telepathy for Delta Chat + +## Who + +Authored by [Nick Thomas](https://ur.gs) under the [MIT License](LICENSE). + +## What + +[Delta Chat](https://delta.chat) is IM over email. +[Telepathy](https://telepathy.freedesktop.org) is a framework for abstracting +over multiple IM protocols. This project glues the two together, allowing +Telepathy clients to send/receive Delta messages. + +Telepathy CMs should have a name that is not the same as their protocol; so this +CM is hereby named "padfoot". + +## Why + +Mobile IM, mostly. Desktop IM, also. It's ideal for my pinephone, and lighter +than the electron desktop client. + +## How + +This project is written in Rust, just like the main Delta library, so you'll +need a rust compiler to build it. + +It makes use of the `dbus-codegen-rust` crate to convert the +[telepathy interface specs](https://github.com/TelepathyIM/telepathy-spec) into +the executable code in `src/telepathy`. This is checked in, but can be +regenerated like so: + +```bash +$ git submodule init telepathy-spec +$ git submodule update telepathy-spec +$ cargo install dbus-codegen-rust +$ ./scripts/dbus-codegen +``` + +`dbus-codegen-rust` doesn't seem to handle namespaced attributes properly, so +we modify the XML files in `telepathy-spec`... with `sed`. The `tp:type` +attribute is renamed to `tp:typehint`. diff --git a/scripts/dbus-codegen b/scripts/dbus-codegen new file mode 100755 index 0000000..3c1cdc6 --- /dev/null +++ b/scripts/dbus-codegen @@ -0,0 +1,38 @@ +#!/bin/sh + +specs="telepathy-spec/spec" +dest="src/telepathy" +modfile="$dest.rs" + +#if [ -d "$dest" ]; then +# mv "$dest" "$dest.$$" +#fi + +rm -f "$dest.rs" +rm -rf "$dest" +mkdir -p "$dest" + +echo "#![allow(unused)]\n#![allow(clippy::all)]" > "$modfile" + +for file in $(ls -a $specs/*.xml); do + sed -i 's/tp:type=/tp:typehint=/g' "$file" + + name=$( \ + echo $(basename "$file") | \ + tr '[:upper:]' '[:lower:]' | \ + tr '-' '_' | \ + sed --expression 's/\.xml$//' \ + ) + out="$dest/$name.rs" + + dbus-codegen-rust \ + --file "$file" \ + -i "org.freedesktop.Telepathy" \ + -o "$out" + + rustfmt $out + + echo "\nmod $name;\npub use self::$name::*;" >> "$modfile" +done + +git -C telepathy-spec checkout -- . diff --git a/src/main.rs b/src/main.rs new file mode 100644 index 0000000..02c6503 --- /dev/null +++ b/src/main.rs @@ -0,0 +1,73 @@ +mod padfoot; +mod telepathy; + +//use dbus::tree::{Interface, MTFn, MethodErr}; +use dbus::{ + blocking::{stdintf::org_freedesktop_dbus::RequestNameReply, LocalConnection}, + tree::{Factory, Interface, MTFn, Tree}, +}; + +use padfoot::{CMData, ConnectionManager}; + +use std::sync::Arc; +use std::time::Duration; + +use anyhow::{anyhow, Result}; + +const BUS_NAME: &'static str = "org.freedesktop.Telepathy.ConnectionManager.padfoot"; +const OBJECT_PATH: &'static str = "/org/freedesktop/Telepathy/ConnectionManager/padfoot"; + +fn create_tree(cm: &Arc) -> Tree, CMData> { + let f = Factory::new_fn(); + let mut tree = f.tree(()); + + let iface = telepathy::connection_manager_server(&f, (), |m| { + let a: &Arc = m.path.get_data(); + let b: &ConnectionManager = &a; + + b + }); + + tree = tree.add( + f.object_path(OBJECT_PATH, cm.clone()) + .introspectable() + .add(iface), + ); + tree = tree.add(f.object_path("/", cm.clone()).introspectable()); + + tree +} + +fn run() -> Result<()> { + let cm: ConnectionManager = ConnectionManager {}; + let tree = create_tree(&Arc::new(cm)); + + // Setup DBus connection + let mut c = LocalConnection::new_session()?; + + let result = c.request_name(BUS_NAME, false, false, true)?; + match result { + RequestNameReply::Exists => { + return Err(anyhow!( + "Another process is already registered on {}", + BUS_NAME + )) + } + _ => {} // All other responses we can get are a success + }; + + println!("Bus registered: {}", BUS_NAME); + tree.start_receive(&c); + + loop { + c.process(Duration::from_secs(1))?; + println!("Tick"); + } +} + +fn main() { + if let Err(e) = run() { + println!("{}", e); + std::process::exit(1); + } +} diff --git a/src/padfoot.rs b/src/padfoot.rs new file mode 100644 index 0000000..3c6feb2 --- /dev/null +++ b/src/padfoot.rs @@ -0,0 +1,5 @@ +mod connection_manager; +pub use self::connection_manager::*; + +mod protocol; +pub use self::protocol::*; diff --git a/src/padfoot/connection_manager.rs b/src/padfoot/connection_manager.rs new file mode 100644 index 0000000..ecbe17d --- /dev/null +++ b/src/padfoot/connection_manager.rs @@ -0,0 +1,64 @@ +use crate::telepathy; +use dbus::{arg, tree}; +use std::collections::HashMap; + +#[derive(Debug)] +pub struct ConnectionManager {} + +#[derive(Copy, Clone, Default, Debug)] +pub struct CMData; + +impl dbus::tree::DataType for CMData { + type Tree = (); + type Property = (); + type Interface = (); + type Method = (); + type Signal = (); + type ObjectPath = std::sync::Arc; +} + +const PROTO: &'static str = "delta"; + +pub type Dict = HashMap>>; + +impl telepathy::ConnectionManager for ConnectionManager { + fn get_parameters( + &self, + protocol: &str, + ) -> Result< + Vec<( + String, + u32, + String, + arg::Variant>, + )>, + tree::MethodErr, + > { + Err(tree::MethodErr::no_arg()) // FIXME: should be NotImplemented + } + + fn list_protocols(&self) -> Result, tree::MethodErr> { + Ok(vec![PROTO.to_string()]) + } + + fn request_connection( + &self, + protocol: &str, + parameters: HashMap<&str, arg::Variant>>, + ) -> Result<(String, dbus::Path<'static>), tree::MethodErr> { + Err(tree::MethodErr::no_arg()) + } + + fn protocols(&self) -> Result, tree::MethodErr> { + let mut hm = HashMap::new(); + let mut props = Dict::new(); + + hm.insert(PROTO.to_string(), props); + + Ok(hm) + } + + fn interfaces(&self) -> Result, tree::MethodErr> { + Err(tree::MethodErr::no_arg()) + } +} diff --git a/src/padfoot/protocol.rs b/src/padfoot/protocol.rs new file mode 100644 index 0000000..69d53fc --- /dev/null +++ b/src/padfoot/protocol.rs @@ -0,0 +1,2 @@ +pub struct Protocol {} + diff --git a/src/telepathy.rs b/src/telepathy.rs new file mode 100644 index 0000000..c0ff449 --- /dev/null +++ b/src/telepathy.rs @@ -0,0 +1,365 @@ +#![allow(unused)] +#![allow(clippy::all)] + +mod account_interface_addressing; +pub use self::account_interface_addressing::*; + +mod account_interface_avatar; +pub use self::account_interface_avatar::*; + +mod account_interface_external_password_storage; +pub use self::account_interface_external_password_storage::*; + +mod account_interface_hidden; +pub use self::account_interface_hidden::*; + +mod account_interface_storage; +pub use self::account_interface_storage::*; + +mod account_manager_interface_hidden; +pub use self::account_manager_interface_hidden::*; + +mod account_manager; +pub use self::account_manager::*; + +mod account; +pub use self::account::*; + +mod all; +pub use self::all::*; + +mod authentication_tls_certificate; +pub use self::authentication_tls_certificate::*; + +mod call_content_interface_audio_control; +pub use self::call_content_interface_audio_control::*; + +mod call_content_interface_dtmf; +pub use self::call_content_interface_dtmf::*; + +mod call_content_interface_media; +pub use self::call_content_interface_media::*; + +mod call_content_interface_video_control; +pub use self::call_content_interface_video_control::*; + +mod call_content_media_description_interface_rtcp_extended_reports; +pub use self::call_content_media_description_interface_rtcp_extended_reports::*; + +mod call_content_media_description_interface_rtcp_feedback; +pub use self::call_content_media_description_interface_rtcp_feedback::*; + +mod call_content_media_description_interface_rtp_header_extensions; +pub use self::call_content_media_description_interface_rtp_header_extensions::*; + +mod call_content_media_description; +pub use self::call_content_media_description::*; + +mod call_content; +pub use self::call_content::*; + +mod call_interface_mute; +pub use self::call_interface_mute::*; + +mod call_stream_endpoint; +pub use self::call_stream_endpoint::*; + +mod call_stream_interface_media; +pub use self::call_stream_interface_media::*; + +mod call_stream; +pub use self::call_stream::*; + +mod channel_bundle; +pub use self::channel_bundle::*; + +mod channel_dispatcher_interface_messages1; +pub use self::channel_dispatcher_interface_messages1::*; + +mod channel_dispatcher_interface_operation_list; +pub use self::channel_dispatcher_interface_operation_list::*; + +mod channel_dispatcher; +pub use self::channel_dispatcher::*; + +mod channel_dispatch_operation; +pub use self::channel_dispatch_operation::*; + +mod channel_future; +pub use self::channel_future::*; + +mod channel_handler; +pub use self::channel_handler::*; + +mod channel_interface_addressing; +pub use self::channel_interface_addressing::*; + +mod channel_interface_anonymity; +pub use self::channel_interface_anonymity::*; + +mod channel_interface_call_state; +pub use self::channel_interface_call_state::*; + +mod channel_interface_captcha_authentication; +pub use self::channel_interface_captcha_authentication::*; + +mod channel_interface_chat_state; +pub use self::channel_interface_chat_state::*; + +mod channel_interface_conference; +pub use self::channel_interface_conference::*; + +mod channel_interface_credentials_storage; +pub use self::channel_interface_credentials_storage::*; + +mod channel_interface_destroyable; +pub use self::channel_interface_destroyable::*; + +mod channel_interface_dtmf; +pub use self::channel_interface_dtmf::*; + +mod channel_interface_file_transfer_metadata; +pub use self::channel_interface_file_transfer_metadata::*; + +mod channel_interface_group; +pub use self::channel_interface_group::*; + +mod channel_interface_hold; +pub use self::channel_interface_hold::*; + +mod channel_interface_html; +pub use self::channel_interface_html::*; + +mod channel_interface_media_signalling; +pub use self::channel_interface_media_signalling::*; + +mod channel_interface_mergeable_conference; +pub use self::channel_interface_mergeable_conference::*; + +mod channel_interface_messages; +pub use self::channel_interface_messages::*; + +mod channel_interface_password; +pub use self::channel_interface_password::*; + +mod channel_interface_picture; +pub use self::channel_interface_picture::*; + +mod channel_interface_room_config; +pub use self::channel_interface_room_config::*; + +mod channel_interface_room; +pub use self::channel_interface_room::*; + +mod channel_interface_sasl_authentication; +pub use self::channel_interface_sasl_authentication::*; + +mod channel_interface_securable; +pub use self::channel_interface_securable::*; + +mod channel_interface_service_point; +pub use self::channel_interface_service_point::*; + +mod channel_interface_sms; +pub use self::channel_interface_sms::*; + +mod channel_interface_splittable; +pub use self::channel_interface_splittable::*; + +mod channel_interface_subject; +pub use self::channel_interface_subject::*; + +mod channel_interface_transfer; +pub use self::channel_interface_transfer::*; + +mod channel_interface_tube; +pub use self::channel_interface_tube::*; + +mod channel_request; +pub use self::channel_request::*; + +mod channel_type_call; +pub use self::channel_type_call::*; + +mod channel_type_contact_list; +pub use self::channel_type_contact_list::*; + +mod channel_type_contact_search; +pub use self::channel_type_contact_search::*; + +mod channel_type_dbus_tube; +pub use self::channel_type_dbus_tube::*; + +mod channel_type_file_transfer; +pub use self::channel_type_file_transfer::*; + +mod channel_type_room_list; +pub use self::channel_type_room_list::*; + +mod channel_type_server_authentication; +pub use self::channel_type_server_authentication::*; + +mod channel_type_server_tls_connection; +pub use self::channel_type_server_tls_connection::*; + +mod channel_type_streamed_media; +pub use self::channel_type_streamed_media::*; + +mod channel_type_stream_tube; +pub use self::channel_type_stream_tube::*; + +mod channel_type_text; +pub use self::channel_type_text::*; + +mod channel_type_tubes; +pub use self::channel_type_tubes::*; + +mod channel; +pub use self::channel::*; + +mod client_approver; +pub use self::client_approver::*; + +mod client_handler_future; +pub use self::client_handler_future::*; + +mod client_handler; +pub use self::client_handler::*; + +mod client_interface_requests; +pub use self::client_interface_requests::*; + +mod client_observer; +pub use self::client_observer::*; + +mod client; +pub use self::client::*; + +mod connection_interface_addressing; +pub use self::connection_interface_addressing::*; + +mod connection_interface_aliasing; +pub use self::connection_interface_aliasing::*; + +mod connection_interface_anonymity; +pub use self::connection_interface_anonymity::*; + +mod connection_interface_avatars; +pub use self::connection_interface_avatars::*; + +mod connection_interface_balance; +pub use self::connection_interface_balance::*; + +mod connection_interface_capabilities; +pub use self::connection_interface_capabilities::*; + +mod connection_interface_cellular; +pub use self::connection_interface_cellular::*; + +mod connection_interface_client_types; +pub use self::connection_interface_client_types::*; + +mod connection_interface_communication_policy; +pub use self::connection_interface_communication_policy::*; + +mod connection_interface_contact_blocking; +pub use self::connection_interface_contact_blocking::*; + +mod connection_interface_contact_capabilities; +pub use self::connection_interface_contact_capabilities::*; + +mod connection_interface_contact_groups; +pub use self::connection_interface_contact_groups::*; + +mod connection_interface_contact_info; +pub use self::connection_interface_contact_info::*; + +mod connection_interface_contact_list; +pub use self::connection_interface_contact_list::*; + +mod connection_interface_contacts; +pub use self::connection_interface_contacts::*; + +mod connection_interface_forwarding; +pub use self::connection_interface_forwarding::*; + +mod connection_interface_irc_command1; +pub use self::connection_interface_irc_command1::*; + +mod connection_interface_keepalive; +pub use self::connection_interface_keepalive::*; + +mod connection_interface_location; +pub use self::connection_interface_location::*; + +mod connection_interface_mail_notification; +pub use self::connection_interface_mail_notification::*; + +mod connection_interface_power_saving; +pub use self::connection_interface_power_saving::*; + +mod connection_interface_presence; +pub use self::connection_interface_presence::*; + +mod connection_interface_privacy; +pub use self::connection_interface_privacy::*; + +mod connection_interface_renaming; +pub use self::connection_interface_renaming::*; + +mod connection_interface_requests; +pub use self::connection_interface_requests::*; + +mod connection_interface_resources; +pub use self::connection_interface_resources::*; + +mod connection_interface_service_point; +pub use self::connection_interface_service_point::*; + +mod connection_interface_sidecars1; +pub use self::connection_interface_sidecars1::*; + +mod connection_interface_simple_presence; +pub use self::connection_interface_simple_presence::*; + +mod connection_manager_interface_account_storage; +pub use self::connection_manager_interface_account_storage::*; + +mod connection_manager; +pub use self::connection_manager::*; + +mod connection; +pub use self::connection::*; + +mod debug; +pub use self::debug::*; + +mod errors; +pub use self::errors::*; + +mod generic_types; +pub use self::generic_types::*; + +mod media_session_handler; +pub use self::media_session_handler::*; + +mod media_stream_handler; +pub use self::media_stream_handler::*; + +mod properties_interface; +pub use self::properties_interface::*; + +mod protocol_interface_addressing; +pub use self::protocol_interface_addressing::*; + +mod protocol_interface_avatars; +pub use self::protocol_interface_avatars::*; + +mod protocol_interface_presence; +pub use self::protocol_interface_presence::*; + +mod protocol; +pub use self::protocol::*; + +mod template; +pub use self::template::*; diff --git a/src/telepathy/account.rs b/src/telepathy/account.rs new file mode 100644 index 0000000..330e2ab --- /dev/null +++ b/src/telepathy/account.rs @@ -0,0 +1,459 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Account.xml -i org.freedesktop.Telepathy -o src/telepathy/account.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait Account { + fn remove(&self) -> Result<(), tree::MethodErr>; + fn update_parameters( + &self, + set: ::std::collections::HashMap<&str, arg::Variant>>, + unset: Vec<&str>, + ) -> Result, tree::MethodErr>; + fn reconnect(&self) -> Result<(), tree::MethodErr>; + fn interfaces(&self) -> Result, tree::MethodErr>; + fn display_name(&self) -> Result; + fn set_display_name(&self, value: String) -> Result<(), tree::MethodErr>; + fn icon(&self) -> Result; + fn set_icon(&self, value: String) -> Result<(), tree::MethodErr>; + fn valid(&self) -> Result; + fn enabled(&self) -> Result; + fn set_enabled(&self, value: bool) -> Result<(), tree::MethodErr>; + fn nickname(&self) -> Result; + fn set_nickname(&self, value: String) -> Result<(), tree::MethodErr>; + fn service(&self) -> Result; + fn set_service(&self, value: String) -> Result<(), tree::MethodErr>; + fn parameters( + &self, + ) -> Result< + ::std::collections::HashMap>>, + tree::MethodErr, + >; + fn automatic_presence(&self) -> Result<(u32, String, String), tree::MethodErr>; + fn set_automatic_presence(&self, value: (u32, String, String)) -> Result<(), tree::MethodErr>; + fn connect_automatically(&self) -> Result; + fn set_connect_automatically(&self, value: bool) -> Result<(), tree::MethodErr>; + fn connection(&self) -> Result, tree::MethodErr>; + fn connection_status(&self) -> Result; + fn connection_status_reason(&self) -> Result; + fn connection_error(&self) -> Result; + fn connection_error_details( + &self, + ) -> Result< + ::std::collections::HashMap>>, + tree::MethodErr, + >; + fn current_presence(&self) -> Result<(u32, String, String), tree::MethodErr>; + fn requested_presence(&self) -> Result<(u32, String, String), tree::MethodErr>; + fn set_requested_presence(&self, value: (u32, String, String)) -> Result<(), tree::MethodErr>; + fn changing_presence(&self) -> Result; + fn normalized_name(&self) -> Result; + fn has_been_online(&self) -> Result; + fn supersedes(&self) -> Result>, tree::MethodErr>; + fn set_supersedes(&self, value: Vec>) -> Result<(), tree::MethodErr>; +} + +pub fn account_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + D::Signal: Default, + T: Account, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface("org.freedesktop.Telepathy.Account", data); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let d = fclone(minfo); + d.remove()?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("Remove", Default::default(), h); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let set: ::std::collections::HashMap<&str, arg::Variant>> = + i.read()?; + let unset: Vec<&str> = i.read()?; + let d = fclone(minfo); + let reconnect_required = d.update_parameters(set, unset)?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(reconnect_required); + Ok(vec![rm]) + }; + let m = factory.method("UpdateParameters", Default::default(), h); + let m = m.in_arg(("Set", "a{sv}")); + let m = m.in_arg(("Unset", "as")); + let m = m.out_arg(("Reconnect_Required", "as")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let d = fclone(minfo); + d.reconnect()?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("Reconnect", Default::default(), h); + let i = i.add_m(m); + + let p = factory.property::, _>("Interfaces", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.interfaces()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::<&str, _>("DisplayName", Default::default()); + let p = p.access(tree::Access::ReadWrite); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.display_name()?); + Ok(()) + }); + let fclone = f.clone(); + let p = p.on_set(move |iter, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + d.set_display_name(iter.read()?)?; + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::<&str, _>("Icon", Default::default()); + let p = p.access(tree::Access::ReadWrite); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.icon()?); + Ok(()) + }); + let fclone = f.clone(); + let p = p.on_set(move |iter, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + d.set_icon(iter.read()?)?; + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("Valid", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.valid()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("Enabled", Default::default()); + let p = p.access(tree::Access::ReadWrite); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.enabled()?); + Ok(()) + }); + let fclone = f.clone(); + let p = p.on_set(move |iter, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + d.set_enabled(iter.read()?)?; + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::<&str, _>("Nickname", Default::default()); + let p = p.access(tree::Access::ReadWrite); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.nickname()?); + Ok(()) + }); + let fclone = f.clone(); + let p = p.on_set(move |iter, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + d.set_nickname(iter.read()?)?; + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::<&str, _>("Service", Default::default()); + let p = p.access(tree::Access::ReadWrite); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.service()?); + Ok(()) + }); + let fclone = f.clone(); + let p = p.on_set(move |iter, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + d.set_service(iter.read()?)?; + Ok(()) + }); + let i = i.add_p(p); + + let p = factory + .property::<::std::collections::HashMap<&str, arg::Variant>>, _>( + "Parameters", + Default::default(), + ); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.parameters()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::<(u32, &str, &str), _>("AutomaticPresence", Default::default()); + let p = p.access(tree::Access::ReadWrite); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.automatic_presence()?); + Ok(()) + }); + let fclone = f.clone(); + let p = p.on_set(move |iter, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + d.set_automatic_presence(iter.read()?)?; + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("ConnectAutomatically", Default::default()); + let p = p.access(tree::Access::ReadWrite); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.connect_automatically()?); + Ok(()) + }); + let fclone = f.clone(); + let p = p.on_set(move |iter, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + d.set_connect_automatically(iter.read()?)?; + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("Connection", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.connection()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("ConnectionStatus", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.connection_status()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("ConnectionStatusReason", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.connection_status_reason()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::<&str, _>("ConnectionError", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.connection_error()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory + .property::<::std::collections::HashMap<&str, arg::Variant>>, _>( + "ConnectionErrorDetails", + Default::default(), + ); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.connection_error_details()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::<(u32, &str, &str), _>("CurrentPresence", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.current_presence()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::<(u32, &str, &str), _>("RequestedPresence", Default::default()); + let p = p.access(tree::Access::ReadWrite); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.requested_presence()?); + Ok(()) + }); + let fclone = f.clone(); + let p = p.on_set(move |iter, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + d.set_requested_presence(iter.read()?)?; + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("ChangingPresence", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.changing_presence()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::<&str, _>("NormalizedName", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.normalized_name()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("HasBeenOnline", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.has_been_online()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::, _>("Supersedes", Default::default()); + let p = p.access(tree::Access::ReadWrite); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.supersedes()?); + Ok(()) + }); + let fclone = f.clone(); + let p = p.on_set(move |iter, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + d.set_supersedes(iter.read()?)?; + Ok(()) + }); + let i = i.add_p(p); + let s = factory.signal("Removed", Default::default()); + let i = i.add_s(s); + let s = factory.signal("AccountPropertyChanged", Default::default()); + let s = s.arg(("Properties", "a{sv}")); + let i = i.add_s(s); + i +} + +#[derive(Debug)] +pub struct AccountRemoved {} + +impl arg::AppendAll for AccountRemoved { + fn append(&self, _: &mut arg::IterAppend) {} +} + +impl arg::ReadAll for AccountRemoved { + fn read(_: &mut arg::Iter) -> Result { + Ok(AccountRemoved {}) + } +} + +impl dbus::message::SignalArgs for AccountRemoved { + const NAME: &'static str = "Removed"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Account"; +} + +#[derive(Debug)] +pub struct AccountAccountPropertyChanged { + pub properties: + ::std::collections::HashMap>>, +} + +impl arg::AppendAll for AccountAccountPropertyChanged { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.properties, i); + } +} + +impl arg::ReadAll for AccountAccountPropertyChanged { + fn read(i: &mut arg::Iter) -> Result { + Ok(AccountAccountPropertyChanged { + properties: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for AccountAccountPropertyChanged { + const NAME: &'static str = "AccountPropertyChanged"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Account"; +} diff --git a/src/telepathy/account_interface_addressing.rs b/src/telepathy/account_interface_addressing.rs new file mode 100644 index 0000000..50cb101 --- /dev/null +++ b/src/telepathy/account_interface_addressing.rs @@ -0,0 +1,58 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Account_Interface_Addressing.xml -i org.freedesktop.Telepathy -o src/telepathy/account_interface_addressing.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait AccountInterfaceAddressing { + fn set_urischeme_association( + &self, + urischeme: &str, + association: bool, + ) -> Result<(), tree::MethodErr>; + fn urischemes(&self) -> Result, tree::MethodErr>; +} + +pub fn account_interface_addressing_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + T: AccountInterfaceAddressing, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface( + "org.freedesktop.Telepathy.Account.Interface.Addressing", + data, + ); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let urischeme: &str = i.read()?; + let association: bool = i.read()?; + let d = fclone(minfo); + d.set_urischeme_association(urischeme, association)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("SetURISchemeAssociation", Default::default(), h); + let m = m.in_arg(("URI_Scheme", "s")); + let m = m.in_arg(("Association", "b")); + let i = i.add_m(m); + + let p = factory.property::, _>("URISchemes", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.urischemes()?); + Ok(()) + }); + let i = i.add_p(p); + i +} diff --git a/src/telepathy/account_interface_avatar.rs b/src/telepathy/account_interface_avatar.rs new file mode 100644 index 0000000..3740926 --- /dev/null +++ b/src/telepathy/account_interface_avatar.rs @@ -0,0 +1,64 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Account_Interface_Avatar.xml -i org.freedesktop.Telepathy -o src/telepathy/account_interface_avatar.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait AccountInterfaceAvatar { + fn avatar(&self) -> Result<(Vec, String), tree::MethodErr>; + fn set_avatar(&self, value: (Vec, String)) -> Result<(), tree::MethodErr>; +} + +pub fn account_interface_avatar_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + D::Signal: Default, + T: AccountInterfaceAvatar, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface("org.freedesktop.Telepathy.Account.Interface.Avatar", data); + let f = ::std::sync::Arc::new(f); + let p = factory.property::<(Vec, &str), _>("Avatar", Default::default()); + let p = p.access(tree::Access::ReadWrite); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.avatar()?); + Ok(()) + }); + let fclone = f.clone(); + let p = p.on_set(move |iter, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + d.set_avatar(iter.read()?)?; + Ok(()) + }); + let i = i.add_p(p); + let s = factory.signal("AvatarChanged", Default::default()); + let i = i.add_s(s); + i +} + +#[derive(Debug)] +pub struct AccountInterfaceAvatarAvatarChanged {} + +impl arg::AppendAll for AccountInterfaceAvatarAvatarChanged { + fn append(&self, _: &mut arg::IterAppend) {} +} + +impl arg::ReadAll for AccountInterfaceAvatarAvatarChanged { + fn read(_: &mut arg::Iter) -> Result { + Ok(AccountInterfaceAvatarAvatarChanged {}) + } +} + +impl dbus::message::SignalArgs for AccountInterfaceAvatarAvatarChanged { + const NAME: &'static str = "AvatarChanged"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Account.Interface.Avatar"; +} diff --git a/src/telepathy/account_interface_external_password_storage.rs b/src/telepathy/account_interface_external_password_storage.rs new file mode 100644 index 0000000..b9b5325 --- /dev/null +++ b/src/telepathy/account_interface_external_password_storage.rs @@ -0,0 +1,49 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Account_Interface_External_Password_Storage.xml -i org.freedesktop.Telepathy -o src/telepathy/account_interface_external_password_storage.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait AccountInterfaceExternalPasswordStorageDRAFT { + fn forget_password(&self) -> Result<(), tree::MethodErr>; + fn password_saved(&self) -> Result; +} + +pub fn account_interface_external_password_storage_draft_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + T: AccountInterfaceExternalPasswordStorageDRAFT, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface( + "org.freedesktop.Telepathy.Account.Interface.ExternalPasswordStorage.DRAFT", + data, + ); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let d = fclone(minfo); + d.forget_password()?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("ForgetPassword", Default::default(), h); + let i = i.add_m(m); + + let p = factory.property::("PasswordSaved", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.password_saved()?); + Ok(()) + }); + let i = i.add_p(p); + i +} diff --git a/src/telepathy/account_interface_hidden.rs b/src/telepathy/account_interface_hidden.rs new file mode 100644 index 0000000..9c7b95b --- /dev/null +++ b/src/telepathy/account_interface_hidden.rs @@ -0,0 +1,38 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Account_Interface_Hidden.xml -i org.freedesktop.Telepathy -o src/telepathy/account_interface_hidden.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait AccountInterfaceHiddenDRAFT1 { + fn hidden(&self) -> Result; +} + +pub fn account_interface_hidden_draft1_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + T: AccountInterfaceHiddenDRAFT1, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface( + "org.freedesktop.Telepathy.Account.Interface.Hidden.DRAFT1", + data, + ); + let f = ::std::sync::Arc::new(f); + let p = factory.property::("Hidden", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.hidden()?); + Ok(()) + }); + let i = i.add_p(p); + i +} diff --git a/src/telepathy/account_interface_storage.rs b/src/telepathy/account_interface_storage.rs new file mode 100644 index 0000000..f99aa8c --- /dev/null +++ b/src/telepathy/account_interface_storage.rs @@ -0,0 +1,83 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Account_Interface_Storage.xml -i org.freedesktop.Telepathy -o src/telepathy/account_interface_storage.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait AccountInterfaceStorage { + fn storage_provider(&self) -> Result; + fn storage_identifier( + &self, + ) -> Result>, tree::MethodErr>; + fn storage_specific_information( + &self, + ) -> Result< + ::std::collections::HashMap>>, + tree::MethodErr, + >; + fn storage_restrictions(&self) -> Result; +} + +pub fn account_interface_storage_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + T: AccountInterfaceStorage, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface("org.freedesktop.Telepathy.Account.Interface.Storage", data); + let f = ::std::sync::Arc::new(f); + let p = factory.property::<&str, _>("StorageProvider", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.storage_provider()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory + .property::>, _>("StorageIdentifier", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.storage_identifier()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory + .property::<::std::collections::HashMap<&str, arg::Variant>>, _>( + "StorageSpecificInformation", + Default::default(), + ); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.storage_specific_information()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("StorageRestrictions", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.storage_restrictions()?); + Ok(()) + }); + let i = i.add_p(p); + i +} diff --git a/src/telepathy/account_manager.rs b/src/telepathy/account_manager.rs new file mode 100644 index 0000000..0510c6f --- /dev/null +++ b/src/telepathy/account_manager.rs @@ -0,0 +1,167 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Account_Manager.xml -i org.freedesktop.Telepathy -o src/telepathy/account_manager.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait AccountManager { + fn create_account( + &self, + connection_manager: &str, + protocol: &str, + display_name: &str, + parameters: ::std::collections::HashMap<&str, arg::Variant>>, + properties: ::std::collections::HashMap<&str, arg::Variant>>, + ) -> Result, tree::MethodErr>; + fn interfaces(&self) -> Result, tree::MethodErr>; + fn valid_accounts(&self) -> Result>, tree::MethodErr>; + fn invalid_accounts(&self) -> Result>, tree::MethodErr>; + fn supported_account_properties(&self) -> Result, tree::MethodErr>; +} + +pub fn account_manager_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + D::Signal: Default, + T: AccountManager, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface("org.freedesktop.Telepathy.AccountManager", data); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let connection_manager: &str = i.read()?; + let protocol: &str = i.read()?; + let display_name: &str = i.read()?; + let parameters: ::std::collections::HashMap<&str, arg::Variant>> = + i.read()?; + let properties: ::std::collections::HashMap<&str, arg::Variant>> = + i.read()?; + let d = fclone(minfo); + let account = d.create_account( + connection_manager, + protocol, + display_name, + parameters, + properties, + )?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(account); + Ok(vec![rm]) + }; + let m = factory.method("CreateAccount", Default::default(), h); + let m = m.in_arg(("Connection_Manager", "s")); + let m = m.in_arg(("Protocol", "s")); + let m = m.in_arg(("Display_Name", "s")); + let m = m.in_arg(("Parameters", "a{sv}")); + let m = m.in_arg(("Properties", "a{sv}")); + let m = m.out_arg(("Account", "o")); + let i = i.add_m(m); + + let p = factory.property::, _>("Interfaces", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.interfaces()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::, _>("ValidAccounts", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.valid_accounts()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::, _>("InvalidAccounts", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.invalid_accounts()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::, _>("SupportedAccountProperties", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.supported_account_properties()?); + Ok(()) + }); + let i = i.add_p(p); + let s = factory.signal("AccountRemoved", Default::default()); + let s = s.arg(("Account", "o")); + let i = i.add_s(s); + let s = factory.signal("AccountValidityChanged", Default::default()); + let s = s.arg(("Account", "o")); + let s = s.arg(("Valid", "b")); + let i = i.add_s(s); + i +} + +#[derive(Debug)] +pub struct AccountManagerAccountRemoved { + pub account: dbus::Path<'static>, +} + +impl arg::AppendAll for AccountManagerAccountRemoved { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.account, i); + } +} + +impl arg::ReadAll for AccountManagerAccountRemoved { + fn read(i: &mut arg::Iter) -> Result { + Ok(AccountManagerAccountRemoved { account: i.read()? }) + } +} + +impl dbus::message::SignalArgs for AccountManagerAccountRemoved { + const NAME: &'static str = "AccountRemoved"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.AccountManager"; +} + +#[derive(Debug)] +pub struct AccountManagerAccountValidityChanged { + pub account: dbus::Path<'static>, + pub valid: bool, +} + +impl arg::AppendAll for AccountManagerAccountValidityChanged { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.account, i); + arg::RefArg::append(&self.valid, i); + } +} + +impl arg::ReadAll for AccountManagerAccountValidityChanged { + fn read(i: &mut arg::Iter) -> Result { + Ok(AccountManagerAccountValidityChanged { + account: i.read()?, + valid: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for AccountManagerAccountValidityChanged { + const NAME: &'static str = "AccountValidityChanged"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.AccountManager"; +} diff --git a/src/telepathy/account_manager_interface_hidden.rs b/src/telepathy/account_manager_interface_hidden.rs new file mode 100644 index 0000000..2e6e87c --- /dev/null +++ b/src/telepathy/account_manager_interface_hidden.rs @@ -0,0 +1,111 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Account_Manager_Interface_Hidden.xml -i org.freedesktop.Telepathy -o src/telepathy/account_manager_interface_hidden.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait AccountManagerInterfaceHiddenDRAFT1 { + fn valid_hidden_accounts(&self) -> Result>, tree::MethodErr>; + fn invalid_hidden_accounts(&self) -> Result>, tree::MethodErr>; +} + +pub fn account_manager_interface_hidden_draft1_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + D::Signal: Default, + T: AccountManagerInterfaceHiddenDRAFT1, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface( + "org.freedesktop.Telepathy.AccountManager.Interface.Hidden.DRAFT1", + data, + ); + let f = ::std::sync::Arc::new(f); + let p = factory.property::, _>("ValidHiddenAccounts", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.valid_hidden_accounts()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::, _>("InvalidHiddenAccounts", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.invalid_hidden_accounts()?); + Ok(()) + }); + let i = i.add_p(p); + let s = factory.signal("HiddenAccountRemoved", Default::default()); + let s = s.arg(("Account", "o")); + let i = i.add_s(s); + let s = factory.signal("HiddenAccountValidityChanged", Default::default()); + let s = s.arg(("Account", "o")); + let s = s.arg(("Valid", "b")); + let i = i.add_s(s); + i +} + +#[derive(Debug)] +pub struct AccountManagerInterfaceHiddenDRAFT1HiddenAccountRemoved { + pub account: dbus::Path<'static>, +} + +impl arg::AppendAll for AccountManagerInterfaceHiddenDRAFT1HiddenAccountRemoved { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.account, i); + } +} + +impl arg::ReadAll for AccountManagerInterfaceHiddenDRAFT1HiddenAccountRemoved { + fn read(i: &mut arg::Iter) -> Result { + Ok(AccountManagerInterfaceHiddenDRAFT1HiddenAccountRemoved { account: i.read()? }) + } +} + +impl dbus::message::SignalArgs for AccountManagerInterfaceHiddenDRAFT1HiddenAccountRemoved { + const NAME: &'static str = "HiddenAccountRemoved"; + const INTERFACE: &'static str = + "org.freedesktop.Telepathy.AccountManager.Interface.Hidden.DRAFT1"; +} + +#[derive(Debug)] +pub struct AccountManagerInterfaceHiddenDRAFT1HiddenAccountValidityChanged { + pub account: dbus::Path<'static>, + pub valid: bool, +} + +impl arg::AppendAll for AccountManagerInterfaceHiddenDRAFT1HiddenAccountValidityChanged { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.account, i); + arg::RefArg::append(&self.valid, i); + } +} + +impl arg::ReadAll for AccountManagerInterfaceHiddenDRAFT1HiddenAccountValidityChanged { + fn read(i: &mut arg::Iter) -> Result { + Ok( + AccountManagerInterfaceHiddenDRAFT1HiddenAccountValidityChanged { + account: i.read()?, + valid: i.read()?, + }, + ) + } +} + +impl dbus::message::SignalArgs for AccountManagerInterfaceHiddenDRAFT1HiddenAccountValidityChanged { + const NAME: &'static str = "HiddenAccountValidityChanged"; + const INTERFACE: &'static str = + "org.freedesktop.Telepathy.AccountManager.Interface.Hidden.DRAFT1"; +} diff --git a/src/telepathy/all.rs b/src/telepathy/all.rs new file mode 100644 index 0000000..2ad51bc --- /dev/null +++ b/src/telepathy/all.rs @@ -0,0 +1,4 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/all.xml -i org.freedesktop.Telepathy -o src/telepathy/all.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; diff --git a/src/telepathy/authentication_tls_certificate.rs b/src/telepathy/authentication_tls_certificate.rs new file mode 100644 index 0000000..d6cdb4a --- /dev/null +++ b/src/telepathy/authentication_tls_certificate.rs @@ -0,0 +1,175 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Authentication_TLS_Certificate.xml -i org.freedesktop.Telepathy -o src/telepathy/authentication_tls_certificate.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait AuthenticationTLSCertificate { + fn accept(&self) -> Result<(), tree::MethodErr>; + fn reject( + &self, + rejections: Vec<( + u32, + &str, + ::std::collections::HashMap<&str, arg::Variant>>, + )>, + ) -> Result<(), tree::MethodErr>; + fn state(&self) -> Result; + fn rejections( + &self, + ) -> Result< + Vec<( + u32, + String, + ::std::collections::HashMap>>, + )>, + tree::MethodErr, + >; + fn certificate_type(&self) -> Result; + fn certificate_chain_data(&self) -> Result>, tree::MethodErr>; +} + +pub fn authentication_tlscertificate_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + D::Signal: Default, + T: AuthenticationTLSCertificate, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface( + "org.freedesktop.Telepathy.Authentication.TLSCertificate", + data, + ); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let d = fclone(minfo); + d.accept()?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("Accept", Default::default(), h); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let rejections: Vec<( + u32, + &str, + ::std::collections::HashMap<&str, arg::Variant>>, + )> = i.read()?; + let d = fclone(minfo); + d.reject(rejections)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("Reject", Default::default(), h); + let m = m.in_arg(("Rejections", "a(usa{sv})")); + let i = i.add_m(m); + + let p = factory.property::("State", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.state()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::>>, + )>, _>("Rejections", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.rejections()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::<&str, _>("CertificateType", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.certificate_type()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::>, _>("CertificateChainData", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.certificate_chain_data()?); + Ok(()) + }); + let i = i.add_p(p); + let s = factory.signal("Accepted", Default::default()); + let i = i.add_s(s); + let s = factory.signal("Rejected", Default::default()); + let s = s.arg(("Rejections", "a(usa{sv})")); + let i = i.add_s(s); + i +} + +#[derive(Debug)] +pub struct AuthenticationTLSCertificateAccepted {} + +impl arg::AppendAll for AuthenticationTLSCertificateAccepted { + fn append(&self, _: &mut arg::IterAppend) {} +} + +impl arg::ReadAll for AuthenticationTLSCertificateAccepted { + fn read(_: &mut arg::Iter) -> Result { + Ok(AuthenticationTLSCertificateAccepted {}) + } +} + +impl dbus::message::SignalArgs for AuthenticationTLSCertificateAccepted { + const NAME: &'static str = "Accepted"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Authentication.TLSCertificate"; +} + +#[derive(Debug)] +pub struct AuthenticationTLSCertificateRejected { + pub rejections: Vec<( + u32, + String, + ::std::collections::HashMap>>, + )>, +} + +impl arg::AppendAll for AuthenticationTLSCertificateRejected { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.rejections, i); + } +} + +impl arg::ReadAll for AuthenticationTLSCertificateRejected { + fn read(i: &mut arg::Iter) -> Result { + Ok(AuthenticationTLSCertificateRejected { + rejections: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for AuthenticationTLSCertificateRejected { + const NAME: &'static str = "Rejected"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Authentication.TLSCertificate"; +} diff --git a/src/telepathy/call_content.rs b/src/telepathy/call_content.rs new file mode 100644 index 0000000..0d30582 --- /dev/null +++ b/src/telepathy/call_content.rs @@ -0,0 +1,151 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Call_Content.xml -i org.freedesktop.Telepathy -o src/telepathy/call_content.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait Call1Content { + fn remove(&self) -> Result<(), tree::MethodErr>; + fn interfaces(&self) -> Result, tree::MethodErr>; + fn name(&self) -> Result; + fn type_(&self) -> Result; + fn disposition(&self) -> Result; + fn streams(&self) -> Result>, tree::MethodErr>; +} + +pub fn call1_content_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + D::Signal: Default, + T: Call1Content, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface("org.freedesktop.Telepathy.Call1.Content", data); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let d = fclone(minfo); + d.remove()?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("Remove", Default::default(), h); + let i = i.add_m(m); + + let p = factory.property::, _>("Interfaces", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.interfaces()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::<&str, _>("Name", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.name()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("Type", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.type_()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("Disposition", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.disposition()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::, _>("Streams", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.streams()?); + Ok(()) + }); + let i = i.add_p(p); + let s = factory.signal("StreamsAdded", Default::default()); + let s = s.arg(("Streams", "ao")); + let i = i.add_s(s); + let s = factory.signal("StreamsRemoved", Default::default()); + let s = s.arg(("Streams", "ao")); + let s = s.arg(("Reason", "(uuss)")); + let i = i.add_s(s); + i +} + +#[derive(Debug)] +pub struct Call1ContentStreamsAdded { + pub streams: Vec>, +} + +impl arg::AppendAll for Call1ContentStreamsAdded { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.streams, i); + } +} + +impl arg::ReadAll for Call1ContentStreamsAdded { + fn read(i: &mut arg::Iter) -> Result { + Ok(Call1ContentStreamsAdded { streams: i.read()? }) + } +} + +impl dbus::message::SignalArgs for Call1ContentStreamsAdded { + const NAME: &'static str = "StreamsAdded"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Content"; +} + +#[derive(Debug)] +pub struct Call1ContentStreamsRemoved { + pub streams: Vec>, + pub reason: (u32, u32, String, String), +} + +impl arg::AppendAll for Call1ContentStreamsRemoved { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.streams, i); + arg::RefArg::append(&self.reason, i); + } +} + +impl arg::ReadAll for Call1ContentStreamsRemoved { + fn read(i: &mut arg::Iter) -> Result { + Ok(Call1ContentStreamsRemoved { + streams: i.read()?, + reason: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for Call1ContentStreamsRemoved { + const NAME: &'static str = "StreamsRemoved"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Content"; +} diff --git a/src/telepathy/call_content_interface_audio_control.rs b/src/telepathy/call_content_interface_audio_control.rs new file mode 100644 index 0000000..f90f9e9 --- /dev/null +++ b/src/telepathy/call_content_interface_audio_control.rs @@ -0,0 +1,78 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Call_Content_Interface_Audio_Control.xml -i org.freedesktop.Telepathy -o src/telepathy/call_content_interface_audio_control.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait Call1ContentInterfaceAudioControl { + fn report_input_volume(&self, volume: i32) -> Result<(), tree::MethodErr>; + fn report_output_volume(&self, volume: i32) -> Result<(), tree::MethodErr>; + fn requested_input_volume(&self) -> Result; + fn requested_output_volume(&self) -> Result; +} + +pub fn call1_content_interface_audio_control_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + T: Call1ContentInterfaceAudioControl, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface( + "org.freedesktop.Telepathy.Call1.Content.Interface.AudioControl", + data, + ); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let volume: i32 = i.read()?; + let d = fclone(minfo); + d.report_input_volume(volume)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("ReportInputVolume", Default::default(), h); + let m = m.in_arg(("Volume", "i")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let volume: i32 = i.read()?; + let d = fclone(minfo); + d.report_output_volume(volume)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("ReportOutputVolume", Default::default(), h); + let m = m.in_arg(("Volume", "i")); + let i = i.add_m(m); + + let p = factory.property::("RequestedInputVolume", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.requested_input_volume()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("RequestedOutputVolume", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.requested_output_volume()?); + Ok(()) + }); + let i = i.add_p(p); + i +} diff --git a/src/telepathy/call_content_interface_dtmf.rs b/src/telepathy/call_content_interface_dtmf.rs new file mode 100644 index 0000000..53bca78 --- /dev/null +++ b/src/telepathy/call_content_interface_dtmf.rs @@ -0,0 +1,167 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Call_Content_Interface_DTMF.xml -i org.freedesktop.Telepathy -o src/telepathy/call_content_interface_dtmf.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait Call1ContentInterfaceDTMF { + fn start_tone(&self, event: u8) -> Result<(), tree::MethodErr>; + fn stop_tone(&self) -> Result<(), tree::MethodErr>; + fn multiple_tones(&self, tones: &str) -> Result<(), tree::MethodErr>; + fn currently_sending_tones(&self) -> Result; + fn deferred_tones(&self) -> Result; +} + +pub fn call1_content_interface_dtmf_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + D::Signal: Default, + T: Call1ContentInterfaceDTMF, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface( + "org.freedesktop.Telepathy.Call1.Content.Interface.DTMF", + data, + ); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let event: u8 = i.read()?; + let d = fclone(minfo); + d.start_tone(event)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("StartTone", Default::default(), h); + let m = m.in_arg(("Event", "y")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let d = fclone(minfo); + d.stop_tone()?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("StopTone", Default::default(), h); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let tones: &str = i.read()?; + let d = fclone(minfo); + d.multiple_tones(tones)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("MultipleTones", Default::default(), h); + let m = m.in_arg(("Tones", "s")); + let i = i.add_m(m); + + let p = factory.property::("CurrentlySendingTones", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.currently_sending_tones()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::<&str, _>("DeferredTones", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.deferred_tones()?); + Ok(()) + }); + let i = i.add_p(p); + let s = factory.signal("TonesDeferred", Default::default()); + let s = s.arg(("Tones", "s")); + let i = i.add_s(s); + let s = factory.signal("SendingTones", Default::default()); + let s = s.arg(("Tones", "s")); + let i = i.add_s(s); + let s = factory.signal("StoppedTones", Default::default()); + let s = s.arg(("Cancelled", "b")); + let i = i.add_s(s); + i +} + +#[derive(Debug)] +pub struct Call1ContentInterfaceDTMFTonesDeferred { + pub tones: String, +} + +impl arg::AppendAll for Call1ContentInterfaceDTMFTonesDeferred { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.tones, i); + } +} + +impl arg::ReadAll for Call1ContentInterfaceDTMFTonesDeferred { + fn read(i: &mut arg::Iter) -> Result { + Ok(Call1ContentInterfaceDTMFTonesDeferred { tones: i.read()? }) + } +} + +impl dbus::message::SignalArgs for Call1ContentInterfaceDTMFTonesDeferred { + const NAME: &'static str = "TonesDeferred"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Content.Interface.DTMF"; +} + +#[derive(Debug)] +pub struct Call1ContentInterfaceDTMFSendingTones { + pub tones: String, +} + +impl arg::AppendAll for Call1ContentInterfaceDTMFSendingTones { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.tones, i); + } +} + +impl arg::ReadAll for Call1ContentInterfaceDTMFSendingTones { + fn read(i: &mut arg::Iter) -> Result { + Ok(Call1ContentInterfaceDTMFSendingTones { tones: i.read()? }) + } +} + +impl dbus::message::SignalArgs for Call1ContentInterfaceDTMFSendingTones { + const NAME: &'static str = "SendingTones"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Content.Interface.DTMF"; +} + +#[derive(Debug)] +pub struct Call1ContentInterfaceDTMFStoppedTones { + pub cancelled: bool, +} + +impl arg::AppendAll for Call1ContentInterfaceDTMFStoppedTones { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.cancelled, i); + } +} + +impl arg::ReadAll for Call1ContentInterfaceDTMFStoppedTones { + fn read(i: &mut arg::Iter) -> Result { + Ok(Call1ContentInterfaceDTMFStoppedTones { + cancelled: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for Call1ContentInterfaceDTMFStoppedTones { + const NAME: &'static str = "StoppedTones"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Content.Interface.DTMF"; +} diff --git a/src/telepathy/call_content_interface_media.rs b/src/telepathy/call_content_interface_media.rs new file mode 100644 index 0000000..0f9f54a --- /dev/null +++ b/src/telepathy/call_content_interface_media.rs @@ -0,0 +1,350 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Call_Content_Interface_Media.xml -i org.freedesktop.Telepathy -o src/telepathy/call_content_interface_media.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait Call1ContentInterfaceMedia { + fn update_local_media_description( + &self, + media_description: ::std::collections::HashMap<&str, arg::Variant>>, + ) -> Result<(), tree::MethodErr>; + fn acknowledge_dtmfchange(&self, event: u8, state: u32) -> Result<(), tree::MethodErr>; + fn fail(&self, reason: (u32, u32, &str, &str)) -> Result<(), tree::MethodErr>; + fn remote_media_descriptions( + &self, + ) -> Result< + ::std::collections::HashMap< + u32, + ::std::collections::HashMap>>, + >, + tree::MethodErr, + >; + fn local_media_descriptions( + &self, + ) -> Result< + ::std::collections::HashMap< + u32, + ::std::collections::HashMap>>, + >, + tree::MethodErr, + >; + fn media_description_offer( + &self, + ) -> Result< + ( + dbus::Path<'static>, + ::std::collections::HashMap>>, + ), + tree::MethodErr, + >; + fn packetization(&self) -> Result; + fn current_dtmfevent(&self) -> Result; + fn current_dtmfstate(&self) -> Result; +} + +pub fn call1_content_interface_media_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + D::Signal: Default, + T: Call1ContentInterfaceMedia, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface( + "org.freedesktop.Telepathy.Call1.Content.Interface.Media", + data, + ); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let media_description: ::std::collections::HashMap< + &str, + arg::Variant>, + > = i.read()?; + let d = fclone(minfo); + d.update_local_media_description(media_description)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("UpdateLocalMediaDescription", Default::default(), h); + let m = m.in_arg(("MediaDescription", "a{sv}")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let event: u8 = i.read()?; + let state: u32 = i.read()?; + let d = fclone(minfo); + d.acknowledge_dtmfchange(event, state)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("AcknowledgeDTMFChange", Default::default(), h); + let m = m.in_arg(("Event", "y")); + let m = m.in_arg(("State", "u")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let reason: (u32, u32, &str, &str) = i.read()?; + let d = fclone(minfo); + d.fail(reason)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("Fail", Default::default(), h); + let m = m.in_arg(("Reason", "(uuss)")); + let i = i.add_m(m); + + let p = factory.property::<::std::collections::HashMap< + u32, + ::std::collections::HashMap<&str, arg::Variant>>, + >, _>("RemoteMediaDescriptions", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.remote_media_descriptions()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::<::std::collections::HashMap< + u32, + ::std::collections::HashMap<&str, arg::Variant>>, + >, _>("LocalMediaDescriptions", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.local_media_descriptions()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::<( + dbus::Path, + ::std::collections::HashMap<&str, arg::Variant>>, + ), _>("MediaDescriptionOffer", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.media_description_offer()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("Packetization", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.packetization()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("CurrentDTMFEvent", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.current_dtmfevent()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("CurrentDTMFState", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.current_dtmfstate()?); + Ok(()) + }); + let i = i.add_p(p); + let s = factory.signal("NewMediaDescriptionOffer", Default::default()); + let s = s.arg(("Media_Description", "o")); + let s = s.arg(("Properties", "a{sv}")); + let i = i.add_s(s); + let s = factory.signal("MediaDescriptionOfferDone", Default::default()); + let i = i.add_s(s); + let s = factory.signal("LocalMediaDescriptionChanged", Default::default()); + let s = s.arg(("Updated_Media_Description", "a{sv}")); + let i = i.add_s(s); + let s = factory.signal("RemoteMediaDescriptionsChanged", Default::default()); + let s = s.arg(("Updated_Media_Descriptions", "a{ua{sv}}")); + let i = i.add_s(s); + let s = factory.signal("MediaDescriptionsRemoved", Default::default()); + let s = s.arg(("Removed_Media_Descriptions", "au")); + let i = i.add_s(s); + let s = factory.signal("DTMFChangeRequested", Default::default()); + let s = s.arg(("Event", "y")); + let s = s.arg(("State", "u")); + let i = i.add_s(s); + i +} + +#[derive(Debug)] +pub struct Call1ContentInterfaceMediaNewMediaDescriptionOffer { + pub media_description: dbus::Path<'static>, + pub properties: + ::std::collections::HashMap>>, +} + +impl arg::AppendAll for Call1ContentInterfaceMediaNewMediaDescriptionOffer { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.media_description, i); + arg::RefArg::append(&self.properties, i); + } +} + +impl arg::ReadAll for Call1ContentInterfaceMediaNewMediaDescriptionOffer { + fn read(i: &mut arg::Iter) -> Result { + Ok(Call1ContentInterfaceMediaNewMediaDescriptionOffer { + media_description: i.read()?, + properties: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for Call1ContentInterfaceMediaNewMediaDescriptionOffer { + const NAME: &'static str = "NewMediaDescriptionOffer"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Content.Interface.Media"; +} + +#[derive(Debug)] +pub struct Call1ContentInterfaceMediaMediaDescriptionOfferDone {} + +impl arg::AppendAll for Call1ContentInterfaceMediaMediaDescriptionOfferDone { + fn append(&self, _: &mut arg::IterAppend) {} +} + +impl arg::ReadAll for Call1ContentInterfaceMediaMediaDescriptionOfferDone { + fn read(_: &mut arg::Iter) -> Result { + Ok(Call1ContentInterfaceMediaMediaDescriptionOfferDone {}) + } +} + +impl dbus::message::SignalArgs for Call1ContentInterfaceMediaMediaDescriptionOfferDone { + const NAME: &'static str = "MediaDescriptionOfferDone"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Content.Interface.Media"; +} + +#[derive(Debug)] +pub struct Call1ContentInterfaceMediaLocalMediaDescriptionChanged { + pub updated_media_description: + ::std::collections::HashMap>>, +} + +impl arg::AppendAll for Call1ContentInterfaceMediaLocalMediaDescriptionChanged { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.updated_media_description, i); + } +} + +impl arg::ReadAll for Call1ContentInterfaceMediaLocalMediaDescriptionChanged { + fn read(i: &mut arg::Iter) -> Result { + Ok(Call1ContentInterfaceMediaLocalMediaDescriptionChanged { + updated_media_description: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for Call1ContentInterfaceMediaLocalMediaDescriptionChanged { + const NAME: &'static str = "LocalMediaDescriptionChanged"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Content.Interface.Media"; +} + +#[derive(Debug)] +pub struct Call1ContentInterfaceMediaRemoteMediaDescriptionsChanged { + pub updated_media_descriptions: ::std::collections::HashMap< + u32, + ::std::collections::HashMap>>, + >, +} + +impl arg::AppendAll for Call1ContentInterfaceMediaRemoteMediaDescriptionsChanged { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.updated_media_descriptions, i); + } +} + +impl arg::ReadAll for Call1ContentInterfaceMediaRemoteMediaDescriptionsChanged { + fn read(i: &mut arg::Iter) -> Result { + Ok(Call1ContentInterfaceMediaRemoteMediaDescriptionsChanged { + updated_media_descriptions: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for Call1ContentInterfaceMediaRemoteMediaDescriptionsChanged { + const NAME: &'static str = "RemoteMediaDescriptionsChanged"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Content.Interface.Media"; +} + +#[derive(Debug)] +pub struct Call1ContentInterfaceMediaMediaDescriptionsRemoved { + pub removed_media_descriptions: Vec, +} + +impl arg::AppendAll for Call1ContentInterfaceMediaMediaDescriptionsRemoved { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.removed_media_descriptions, i); + } +} + +impl arg::ReadAll for Call1ContentInterfaceMediaMediaDescriptionsRemoved { + fn read(i: &mut arg::Iter) -> Result { + Ok(Call1ContentInterfaceMediaMediaDescriptionsRemoved { + removed_media_descriptions: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for Call1ContentInterfaceMediaMediaDescriptionsRemoved { + const NAME: &'static str = "MediaDescriptionsRemoved"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Content.Interface.Media"; +} + +#[derive(Debug)] +pub struct Call1ContentInterfaceMediaDTMFChangeRequested { + pub event: u8, + pub state: u32, +} + +impl arg::AppendAll for Call1ContentInterfaceMediaDTMFChangeRequested { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.event, i); + arg::RefArg::append(&self.state, i); + } +} + +impl arg::ReadAll for Call1ContentInterfaceMediaDTMFChangeRequested { + fn read(i: &mut arg::Iter) -> Result { + Ok(Call1ContentInterfaceMediaDTMFChangeRequested { + event: i.read()?, + state: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for Call1ContentInterfaceMediaDTMFChangeRequested { + const NAME: &'static str = "DTMFChangeRequested"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Content.Interface.Media"; +} diff --git a/src/telepathy/call_content_interface_video_control.rs b/src/telepathy/call_content_interface_video_control.rs new file mode 100644 index 0000000..0e59cf4 --- /dev/null +++ b/src/telepathy/call_content_interface_video_control.rs @@ -0,0 +1,218 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Call_Content_Interface_Video_Control.xml -i org.freedesktop.Telepathy -o src/telepathy/call_content_interface_video_control.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait Call1ContentInterfaceVideoControl { + fn video_resolution(&self) -> Result<(u32, u32), tree::MethodErr>; + fn bitrate(&self) -> Result; + fn framerate(&self) -> Result; + fn mtu(&self) -> Result; + fn manual_key_frames(&self) -> Result; +} + +pub fn call1_content_interface_video_control_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + D::Signal: Default, + T: Call1ContentInterfaceVideoControl, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface( + "org.freedesktop.Telepathy.Call1.Content.Interface.VideoControl", + data, + ); + let f = ::std::sync::Arc::new(f); + let p = factory.property::<(u32, u32), _>("VideoResolution", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.video_resolution()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("Bitrate", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.bitrate()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("Framerate", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.framerate()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("MTU", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.mtu()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("ManualKeyFrames", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.manual_key_frames()?); + Ok(()) + }); + let i = i.add_p(p); + let s = factory.signal("KeyFrameRequested", Default::default()); + let i = i.add_s(s); + let s = factory.signal("VideoResolutionChanged", Default::default()); + let s = s.arg(("NewResolution", "(uu)")); + let i = i.add_s(s); + let s = factory.signal("BitrateChanged", Default::default()); + let s = s.arg(("NewBitrate", "u")); + let i = i.add_s(s); + let s = factory.signal("FramerateChanged", Default::default()); + let s = s.arg(("NewFramerate", "u")); + let i = i.add_s(s); + let s = factory.signal("MTUChanged", Default::default()); + let s = s.arg(("NewMTU", "u")); + let i = i.add_s(s); + i +} + +#[derive(Debug)] +pub struct Call1ContentInterfaceVideoControlKeyFrameRequested {} + +impl arg::AppendAll for Call1ContentInterfaceVideoControlKeyFrameRequested { + fn append(&self, _: &mut arg::IterAppend) {} +} + +impl arg::ReadAll for Call1ContentInterfaceVideoControlKeyFrameRequested { + fn read(_: &mut arg::Iter) -> Result { + Ok(Call1ContentInterfaceVideoControlKeyFrameRequested {}) + } +} + +impl dbus::message::SignalArgs for Call1ContentInterfaceVideoControlKeyFrameRequested { + const NAME: &'static str = "KeyFrameRequested"; + const INTERFACE: &'static str = + "org.freedesktop.Telepathy.Call1.Content.Interface.VideoControl"; +} + +#[derive(Debug)] +pub struct Call1ContentInterfaceVideoControlVideoResolutionChanged { + pub new_resolution: (u32, u32), +} + +impl arg::AppendAll for Call1ContentInterfaceVideoControlVideoResolutionChanged { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.new_resolution, i); + } +} + +impl arg::ReadAll for Call1ContentInterfaceVideoControlVideoResolutionChanged { + fn read(i: &mut arg::Iter) -> Result { + Ok(Call1ContentInterfaceVideoControlVideoResolutionChanged { + new_resolution: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for Call1ContentInterfaceVideoControlVideoResolutionChanged { + const NAME: &'static str = "VideoResolutionChanged"; + const INTERFACE: &'static str = + "org.freedesktop.Telepathy.Call1.Content.Interface.VideoControl"; +} + +#[derive(Debug)] +pub struct Call1ContentInterfaceVideoControlBitrateChanged { + pub new_bitrate: u32, +} + +impl arg::AppendAll for Call1ContentInterfaceVideoControlBitrateChanged { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.new_bitrate, i); + } +} + +impl arg::ReadAll for Call1ContentInterfaceVideoControlBitrateChanged { + fn read(i: &mut arg::Iter) -> Result { + Ok(Call1ContentInterfaceVideoControlBitrateChanged { + new_bitrate: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for Call1ContentInterfaceVideoControlBitrateChanged { + const NAME: &'static str = "BitrateChanged"; + const INTERFACE: &'static str = + "org.freedesktop.Telepathy.Call1.Content.Interface.VideoControl"; +} + +#[derive(Debug)] +pub struct Call1ContentInterfaceVideoControlFramerateChanged { + pub new_framerate: u32, +} + +impl arg::AppendAll for Call1ContentInterfaceVideoControlFramerateChanged { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.new_framerate, i); + } +} + +impl arg::ReadAll for Call1ContentInterfaceVideoControlFramerateChanged { + fn read(i: &mut arg::Iter) -> Result { + Ok(Call1ContentInterfaceVideoControlFramerateChanged { + new_framerate: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for Call1ContentInterfaceVideoControlFramerateChanged { + const NAME: &'static str = "FramerateChanged"; + const INTERFACE: &'static str = + "org.freedesktop.Telepathy.Call1.Content.Interface.VideoControl"; +} + +#[derive(Debug)] +pub struct Call1ContentInterfaceVideoControlMTUChanged { + pub new_mtu: u32, +} + +impl arg::AppendAll for Call1ContentInterfaceVideoControlMTUChanged { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.new_mtu, i); + } +} + +impl arg::ReadAll for Call1ContentInterfaceVideoControlMTUChanged { + fn read(i: &mut arg::Iter) -> Result { + Ok(Call1ContentInterfaceVideoControlMTUChanged { new_mtu: i.read()? }) + } +} + +impl dbus::message::SignalArgs for Call1ContentInterfaceVideoControlMTUChanged { + const NAME: &'static str = "MTUChanged"; + const INTERFACE: &'static str = + "org.freedesktop.Telepathy.Call1.Content.Interface.VideoControl"; +} diff --git a/src/telepathy/call_content_media_description.rs b/src/telepathy/call_content_media_description.rs new file mode 100644 index 0000000..af6b718 --- /dev/null +++ b/src/telepathy/call_content_media_description.rs @@ -0,0 +1,155 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Call_Content_Media_Description.xml -i org.freedesktop.Telepathy -o src/telepathy/call_content_media_description.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait Call1ContentMediaDescription { + fn accept( + &self, + local_media_description: ::std::collections::HashMap< + &str, + arg::Variant>, + >, + ) -> Result<(), tree::MethodErr>; + fn reject(&self, reason: (u32, u32, &str, &str)) -> Result<(), tree::MethodErr>; + fn interfaces(&self) -> Result, tree::MethodErr>; + fn further_negotiation_required(&self) -> Result; + fn has_remote_information(&self) -> Result; + fn codecs( + &self, + ) -> Result< + Vec<( + u32, + String, + u32, + u32, + bool, + ::std::collections::HashMap, + )>, + tree::MethodErr, + >; + fn remote_contact(&self) -> Result; + fn ssrcs(&self) -> Result<::std::collections::HashMap>, tree::MethodErr>; +} + +pub fn call1_content_media_description_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + T: Call1ContentMediaDescription, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface( + "org.freedesktop.Telepathy.Call1.Content.MediaDescription", + data, + ); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let local_media_description: ::std::collections::HashMap< + &str, + arg::Variant>, + > = i.read()?; + let d = fclone(minfo); + d.accept(local_media_description)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("Accept", Default::default(), h); + let m = m.in_arg(("Local_Media_Description", "a{sv}")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let reason: (u32, u32, &str, &str) = i.read()?; + let d = fclone(minfo); + d.reject(reason)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("Reject", Default::default(), h); + let m = m.in_arg(("Reason", "(uuss)")); + let i = i.add_m(m); + + let p = factory.property::, _>("Interfaces", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.interfaces()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("FurtherNegotiationRequired", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.further_negotiation_required()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("HasRemoteInformation", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.has_remote_information()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::, + )>, _>("Codecs", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.codecs()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("RemoteContact", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.remote_contact()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory + .property::<::std::collections::HashMap>, _>("SSRCs", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.ssrcs()?); + Ok(()) + }); + let i = i.add_p(p); + i +} diff --git a/src/telepathy/call_content_media_description_interface_rtcp_extended_reports.rs b/src/telepathy/call_content_media_description_interface_rtcp_extended_reports.rs new file mode 100644 index 0000000..927d33a --- /dev/null +++ b/src/telepathy/call_content_media_description_interface_rtcp_extended_reports.rs @@ -0,0 +1,110 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Call_Content_Media_Description_Interface_RTCP_Extended_Reports.xml -i org.freedesktop.Telepathy -o src/telepathy/call_content_media_description_interface_rtcp_extended_reports.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait Call1ContentMediaDescriptionInterfaceRTCPExtendedReports { + fn loss_rlemax_size(&self) -> Result; + fn duplicate_rlemax_size(&self) -> Result; + fn packet_receipt_times_max_size(&self) -> Result; + fn dlrrmax_size(&self) -> Result; + fn rttmode(&self) -> Result; + fn statistics_flags(&self) -> Result; + fn enable_metrics(&self) -> Result; +} + +pub fn call1_content_media_description_interface_rtcpextended_reports_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + T: Call1ContentMediaDescriptionInterfaceRTCPExtendedReports, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface( + "org.freedesktop.Telepathy.Call1.Content.MediaDescription.Interface.RTCPExtendedReports", + data, + ); + let f = ::std::sync::Arc::new(f); + let p = factory.property::("LossRLEMaxSize", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.loss_rlemax_size()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("DuplicateRLEMaxSize", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.duplicate_rlemax_size()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("PacketReceiptTimesMaxSize", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.packet_receipt_times_max_size()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("DLRRMaxSize", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.dlrrmax_size()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("RTTMode", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.rttmode()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("StatisticsFlags", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.statistics_flags()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("EnableMetrics", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.enable_metrics()?); + Ok(()) + }); + let i = i.add_p(p); + i +} diff --git a/src/telepathy/call_content_media_description_interface_rtcp_feedback.rs b/src/telepathy/call_content_media_description_interface_rtcp_feedback.rs new file mode 100644 index 0000000..d39f9d6 --- /dev/null +++ b/src/telepathy/call_content_media_description_interface_rtcp_feedback.rs @@ -0,0 +1,59 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Call_Content_Media_Description_Interface_RTCP_Feedback.xml -i org.freedesktop.Telepathy -o src/telepathy/call_content_media_description_interface_rtcp_feedback.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait Call1ContentMediaDescriptionInterfaceRTCPFeedback { + fn feedback_messages( + &self, + ) -> Result< + ::std::collections::HashMap)>, + tree::MethodErr, + >; + fn does_avpf(&self) -> Result; +} + +pub fn call1_content_media_description_interface_rtcpfeedback_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + T: Call1ContentMediaDescriptionInterfaceRTCPFeedback, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface( + "org.freedesktop.Telepathy.Call1.Content.MediaDescription.Interface.RTCPFeedback", + data, + ); + let f = ::std::sync::Arc::new(f); + let p = factory + .property::<::std::collections::HashMap)>, _>( + "FeedbackMessages", + Default::default(), + ); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.feedback_messages()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("DoesAVPF", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.does_avpf()?); + Ok(()) + }); + let i = i.add_p(p); + i +} diff --git a/src/telepathy/call_content_media_description_interface_rtp_header_extensions.rs b/src/telepathy/call_content_media_description_interface_rtp_header_extensions.rs new file mode 100644 index 0000000..eee00a7 --- /dev/null +++ b/src/telepathy/call_content_media_description_interface_rtp_header_extensions.rs @@ -0,0 +1,39 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Call_Content_Media_Description_Interface_RTP_Header_Extensions.xml -i org.freedesktop.Telepathy -o src/telepathy/call_content_media_description_interface_rtp_header_extensions.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait Call1ContentMediaDescriptionInterfaceRTPHeaderExtensions { + fn header_extensions(&self) -> Result, tree::MethodErr>; +} + +pub fn call1_content_media_description_interface_rtpheader_extensions_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + T: Call1ContentMediaDescriptionInterfaceRTPHeaderExtensions, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface( + "org.freedesktop.Telepathy.Call1.Content.MediaDescription.Interface.RTPHeaderExtensions", + data, + ); + let f = ::std::sync::Arc::new(f); + let p = + factory.property::, _>("HeaderExtensions", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.header_extensions()?); + Ok(()) + }); + let i = i.add_p(p); + i +} diff --git a/src/telepathy/call_interface_mute.rs b/src/telepathy/call_interface_mute.rs new file mode 100644 index 0000000..c6866dc --- /dev/null +++ b/src/telepathy/call_interface_mute.rs @@ -0,0 +1,77 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Call_Interface_Mute.xml -i org.freedesktop.Telepathy -o src/telepathy/call_interface_mute.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait Call1InterfaceMute { + fn request_muted(&self, muted: bool) -> Result<(), tree::MethodErr>; + fn local_mute_state(&self) -> Result; +} + +pub fn call1_interface_mute_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + D::Signal: Default, + T: Call1InterfaceMute, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface("org.freedesktop.Telepathy.Call1.Interface.Mute", data); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let muted: bool = i.read()?; + let d = fclone(minfo); + d.request_muted(muted)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("RequestMuted", Default::default(), h); + let m = m.in_arg(("Muted", "b")); + let i = i.add_m(m); + + let p = factory.property::("LocalMuteState", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.local_mute_state()?); + Ok(()) + }); + let i = i.add_p(p); + let s = factory.signal("MuteStateChanged", Default::default()); + let s = s.arg(("MuteState", "u")); + let i = i.add_s(s); + i +} + +#[derive(Debug)] +pub struct Call1InterfaceMuteMuteStateChanged { + pub mute_state: u32, +} + +impl arg::AppendAll for Call1InterfaceMuteMuteStateChanged { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.mute_state, i); + } +} + +impl arg::ReadAll for Call1InterfaceMuteMuteStateChanged { + fn read(i: &mut arg::Iter) -> Result { + Ok(Call1InterfaceMuteMuteStateChanged { + mute_state: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for Call1InterfaceMuteMuteStateChanged { + const NAME: &'static str = "MuteStateChanged"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Interface.Mute"; +} diff --git a/src/telepathy/call_stream.rs b/src/telepathy/call_stream.rs new file mode 100644 index 0000000..4cc58cb --- /dev/null +++ b/src/telepathy/call_stream.rs @@ -0,0 +1,190 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Call_Stream.xml -i org.freedesktop.Telepathy -o src/telepathy/call_stream.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait Call1Stream { + fn set_sending(&self, send: bool) -> Result<(), tree::MethodErr>; + fn request_receiving(&self, contact: u32, receive: bool) -> Result<(), tree::MethodErr>; + fn interfaces(&self) -> Result, tree::MethodErr>; + fn remote_members(&self) -> Result<::std::collections::HashMap, tree::MethodErr>; + fn remote_member_identifiers( + &self, + ) -> Result<::std::collections::HashMap, tree::MethodErr>; + fn local_sending_state(&self) -> Result; + fn can_request_receiving(&self) -> Result; +} + +pub fn call1_stream_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + D::Signal: Default, + T: Call1Stream, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface("org.freedesktop.Telepathy.Call1.Stream", data); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let send: bool = i.read()?; + let d = fclone(minfo); + d.set_sending(send)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("SetSending", Default::default(), h); + let m = m.in_arg(("Send", "b")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let contact: u32 = i.read()?; + let receive: bool = i.read()?; + let d = fclone(minfo); + d.request_receiving(contact, receive)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("RequestReceiving", Default::default(), h); + let m = m.in_arg(("Contact", "u")); + let m = m.in_arg(("Receive", "b")); + let i = i.add_m(m); + + let p = factory.property::, _>("Interfaces", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.interfaces()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory + .property::<::std::collections::HashMap, _>("RemoteMembers", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.remote_members()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::<::std::collections::HashMap, _>( + "RemoteMemberIdentifiers", + Default::default(), + ); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.remote_member_identifiers()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("LocalSendingState", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.local_sending_state()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("CanRequestReceiving", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.can_request_receiving()?); + Ok(()) + }); + let i = i.add_p(p); + let s = factory.signal("RemoteMembersChanged", Default::default()); + let s = s.arg(("Updates", "a{uu}")); + let s = s.arg(("Identifiers", "a{us}")); + let s = s.arg(("Removed", "au")); + let s = s.arg(("Reason", "(uuss)")); + let i = i.add_s(s); + let s = factory.signal("LocalSendingStateChanged", Default::default()); + let s = s.arg(("State", "u")); + let s = s.arg(("Reason", "(uuss)")); + let i = i.add_s(s); + i +} + +#[derive(Debug)] +pub struct Call1StreamRemoteMembersChanged { + pub updates: ::std::collections::HashMap, + pub identifiers: ::std::collections::HashMap, + pub removed: Vec, + pub reason: (u32, u32, String, String), +} + +impl arg::AppendAll for Call1StreamRemoteMembersChanged { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.updates, i); + arg::RefArg::append(&self.identifiers, i); + arg::RefArg::append(&self.removed, i); + arg::RefArg::append(&self.reason, i); + } +} + +impl arg::ReadAll for Call1StreamRemoteMembersChanged { + fn read(i: &mut arg::Iter) -> Result { + Ok(Call1StreamRemoteMembersChanged { + updates: i.read()?, + identifiers: i.read()?, + removed: i.read()?, + reason: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for Call1StreamRemoteMembersChanged { + const NAME: &'static str = "RemoteMembersChanged"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Stream"; +} + +#[derive(Debug)] +pub struct Call1StreamLocalSendingStateChanged { + pub state: u32, + pub reason: (u32, u32, String, String), +} + +impl arg::AppendAll for Call1StreamLocalSendingStateChanged { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.state, i); + arg::RefArg::append(&self.reason, i); + } +} + +impl arg::ReadAll for Call1StreamLocalSendingStateChanged { + fn read(i: &mut arg::Iter) -> Result { + Ok(Call1StreamLocalSendingStateChanged { + state: i.read()?, + reason: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for Call1StreamLocalSendingStateChanged { + const NAME: &'static str = "LocalSendingStateChanged"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Stream"; +} diff --git a/src/telepathy/call_stream_endpoint.rs b/src/telepathy/call_stream_endpoint.rs new file mode 100644 index 0000000..70062a3 --- /dev/null +++ b/src/telepathy/call_stream_endpoint.rs @@ -0,0 +1,467 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Call_Stream_Endpoint.xml -i org.freedesktop.Telepathy -o src/telepathy/call_stream_endpoint.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait Call1StreamEndpoint { + fn set_selected_candidate_pair( + &self, + local_candidate: ( + u32, + &str, + u32, + ::std::collections::HashMap<&str, arg::Variant>>, + ), + remote_candidate: ( + u32, + &str, + u32, + ::std::collections::HashMap<&str, arg::Variant>>, + ), + ) -> Result<(), tree::MethodErr>; + fn set_endpoint_state_(&self, component: u32, state: u32) -> Result<(), tree::MethodErr>; + fn accept_selected_candidate_pair( + &self, + local_candidate: ( + u32, + &str, + u32, + ::std::collections::HashMap<&str, arg::Variant>>, + ), + remote_candidate: ( + u32, + &str, + u32, + ::std::collections::HashMap<&str, arg::Variant>>, + ), + ) -> Result<(), tree::MethodErr>; + fn reject_selected_candidate_pair( + &self, + local_candidate: ( + u32, + &str, + u32, + ::std::collections::HashMap<&str, arg::Variant>>, + ), + remote_candidate: ( + u32, + &str, + u32, + ::std::collections::HashMap<&str, arg::Variant>>, + ), + ) -> Result<(), tree::MethodErr>; + fn set_controlling_(&self, controlling: bool) -> Result<(), tree::MethodErr>; + fn remote_credentials(&self) -> Result<(String, String), tree::MethodErr>; + fn remote_candidates( + &self, + ) -> Result< + Vec<( + u32, + String, + u32, + ::std::collections::HashMap>>, + )>, + tree::MethodErr, + >; + fn selected_candidate_pairs( + &self, + ) -> Result< + Vec<( + ( + u32, + String, + u32, + ::std::collections::HashMap>>, + ), + ( + u32, + String, + u32, + ::std::collections::HashMap>>, + ), + )>, + tree::MethodErr, + >; + fn endpoint_state(&self) -> Result<::std::collections::HashMap, tree::MethodErr>; + fn transport(&self) -> Result; + fn controlling(&self) -> Result; + fn is_icelite(&self) -> Result; +} + +pub fn call1_stream_endpoint_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + D::Signal: Default, + T: Call1StreamEndpoint, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface("org.freedesktop.Telepathy.Call1.Stream.Endpoint", data); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let local_candidate: ( + u32, + &str, + u32, + ::std::collections::HashMap<&str, arg::Variant>>, + ) = i.read()?; + let remote_candidate: ( + u32, + &str, + u32, + ::std::collections::HashMap<&str, arg::Variant>>, + ) = i.read()?; + let d = fclone(minfo); + d.set_selected_candidate_pair(local_candidate, remote_candidate)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("SetSelectedCandidatePair", Default::default(), h); + let m = m.in_arg(("Local_Candidate", "(usua{sv})")); + let m = m.in_arg(("Remote_Candidate", "(usua{sv})")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let component: u32 = i.read()?; + let state: u32 = i.read()?; + let d = fclone(minfo); + d.set_endpoint_state_(component, state)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("SetEndpointState", Default::default(), h); + let m = m.in_arg(("Component", "u")); + let m = m.in_arg(("State", "u")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let local_candidate: ( + u32, + &str, + u32, + ::std::collections::HashMap<&str, arg::Variant>>, + ) = i.read()?; + let remote_candidate: ( + u32, + &str, + u32, + ::std::collections::HashMap<&str, arg::Variant>>, + ) = i.read()?; + let d = fclone(minfo); + d.accept_selected_candidate_pair(local_candidate, remote_candidate)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("AcceptSelectedCandidatePair", Default::default(), h); + let m = m.in_arg(("Local_Candidate", "(usua{sv})")); + let m = m.in_arg(("Remote_Candidate", "(usua{sv})")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let local_candidate: ( + u32, + &str, + u32, + ::std::collections::HashMap<&str, arg::Variant>>, + ) = i.read()?; + let remote_candidate: ( + u32, + &str, + u32, + ::std::collections::HashMap<&str, arg::Variant>>, + ) = i.read()?; + let d = fclone(minfo); + d.reject_selected_candidate_pair(local_candidate, remote_candidate)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("RejectSelectedCandidatePair", Default::default(), h); + let m = m.in_arg(("Local_Candidate", "(usua{sv})")); + let m = m.in_arg(("Remote_Candidate", "(usua{sv})")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let controlling: bool = i.read()?; + let d = fclone(minfo); + d.set_controlling_(controlling)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("SetControlling", Default::default(), h); + let m = m.in_arg(("Controlling", "b")); + let i = i.add_m(m); + + let p = factory.property::<(&str, &str), _>("RemoteCredentials", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.remote_credentials()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::>>, + )>, _>("RemoteCandidates", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.remote_candidates()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::>>, + ), + ( + u32, + &str, + u32, + ::std::collections::HashMap<&str, arg::Variant>>, + ), + )>, _>("SelectedCandidatePairs", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.selected_candidate_pairs()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory + .property::<::std::collections::HashMap, _>("EndpointState", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.endpoint_state()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("Transport", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.transport()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("Controlling", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.controlling()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("IsICELite", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.is_icelite()?); + Ok(()) + }); + let i = i.add_p(p); + let s = factory.signal("RemoteCredentialsSet", Default::default()); + let s = s.arg(("Username", "s")); + let s = s.arg(("Password", "s")); + let i = i.add_s(s); + let s = factory.signal("RemoteCandidatesAdded", Default::default()); + let s = s.arg(("Candidates", "a(usua{sv})")); + let i = i.add_s(s); + let s = factory.signal("CandidatePairSelected", Default::default()); + let s = s.arg(("Local_Candidate", "(usua{sv})")); + let s = s.arg(("Remote_Candidate", "(usua{sv})")); + let i = i.add_s(s); + let s = factory.signal("EndpointStateChanged", Default::default()); + let s = s.arg(("Component", "u")); + let s = s.arg(("State", "u")); + let i = i.add_s(s); + let s = factory.signal("ControllingChanged", Default::default()); + let s = s.arg(("Controlling", "b")); + let i = i.add_s(s); + i +} + +#[derive(Debug)] +pub struct Call1StreamEndpointRemoteCredentialsSet { + pub username: String, + pub password: String, +} + +impl arg::AppendAll for Call1StreamEndpointRemoteCredentialsSet { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.username, i); + arg::RefArg::append(&self.password, i); + } +} + +impl arg::ReadAll for Call1StreamEndpointRemoteCredentialsSet { + fn read(i: &mut arg::Iter) -> Result { + Ok(Call1StreamEndpointRemoteCredentialsSet { + username: i.read()?, + password: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for Call1StreamEndpointRemoteCredentialsSet { + const NAME: &'static str = "RemoteCredentialsSet"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Stream.Endpoint"; +} + +#[derive(Debug)] +pub struct Call1StreamEndpointRemoteCandidatesAdded { + pub candidates: Vec<( + u32, + String, + u32, + ::std::collections::HashMap>>, + )>, +} + +impl arg::AppendAll for Call1StreamEndpointRemoteCandidatesAdded { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.candidates, i); + } +} + +impl arg::ReadAll for Call1StreamEndpointRemoteCandidatesAdded { + fn read(i: &mut arg::Iter) -> Result { + Ok(Call1StreamEndpointRemoteCandidatesAdded { + candidates: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for Call1StreamEndpointRemoteCandidatesAdded { + const NAME: &'static str = "RemoteCandidatesAdded"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Stream.Endpoint"; +} + +#[derive(Debug)] +pub struct Call1StreamEndpointCandidatePairSelected { + pub local_candidate: ( + u32, + String, + u32, + ::std::collections::HashMap>>, + ), + pub remote_candidate: ( + u32, + String, + u32, + ::std::collections::HashMap>>, + ), +} + +impl arg::AppendAll for Call1StreamEndpointCandidatePairSelected { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.local_candidate, i); + arg::RefArg::append(&self.remote_candidate, i); + } +} + +impl arg::ReadAll for Call1StreamEndpointCandidatePairSelected { + fn read(i: &mut arg::Iter) -> Result { + Ok(Call1StreamEndpointCandidatePairSelected { + local_candidate: i.read()?, + remote_candidate: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for Call1StreamEndpointCandidatePairSelected { + const NAME: &'static str = "CandidatePairSelected"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Stream.Endpoint"; +} + +#[derive(Debug)] +pub struct Call1StreamEndpointEndpointStateChanged { + pub component: u32, + pub state: u32, +} + +impl arg::AppendAll for Call1StreamEndpointEndpointStateChanged { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.component, i); + arg::RefArg::append(&self.state, i); + } +} + +impl arg::ReadAll for Call1StreamEndpointEndpointStateChanged { + fn read(i: &mut arg::Iter) -> Result { + Ok(Call1StreamEndpointEndpointStateChanged { + component: i.read()?, + state: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for Call1StreamEndpointEndpointStateChanged { + const NAME: &'static str = "EndpointStateChanged"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Stream.Endpoint"; +} + +#[derive(Debug)] +pub struct Call1StreamEndpointControllingChanged { + pub controlling: bool, +} + +impl arg::AppendAll for Call1StreamEndpointControllingChanged { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.controlling, i); + } +} + +impl arg::ReadAll for Call1StreamEndpointControllingChanged { + fn read(i: &mut arg::Iter) -> Result { + Ok(Call1StreamEndpointControllingChanged { + controlling: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for Call1StreamEndpointControllingChanged { + const NAME: &'static str = "ControllingChanged"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Stream.Endpoint"; +} diff --git a/src/telepathy/call_stream_interface_media.rs b/src/telepathy/call_stream_interface_media.rs new file mode 100644 index 0000000..10c4242 --- /dev/null +++ b/src/telepathy/call_stream_interface_media.rs @@ -0,0 +1,550 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Call_Stream_Interface_Media.xml -i org.freedesktop.Telepathy -o src/telepathy/call_stream_interface_media.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait Call1StreamInterfaceMedia { + fn complete_sending_state_change(&self, state: u32) -> Result<(), tree::MethodErr>; + fn report_sending_failure( + &self, + reason: u32, + error: &str, + message: &str, + ) -> Result<(), tree::MethodErr>; + fn complete_receiving_state_change(&self, state: u32) -> Result<(), tree::MethodErr>; + fn report_receiving_failure( + &self, + reason: u32, + error: &str, + message: &str, + ) -> Result<(), tree::MethodErr>; + fn set_credentials(&self, username: &str, password: &str) -> Result<(), tree::MethodErr>; + fn add_candidates( + &self, + candidates: Vec<( + u32, + &str, + u32, + ::std::collections::HashMap<&str, arg::Variant>>, + )>, + ) -> Result<(), tree::MethodErr>; + fn finish_initial_candidates(&self) -> Result<(), tree::MethodErr>; + fn fail(&self, reason: (u32, u32, &str, &str)) -> Result<(), tree::MethodErr>; + fn sending_state(&self) -> Result; + fn receiving_state(&self) -> Result; + fn transport(&self) -> Result; + fn local_candidates( + &self, + ) -> Result< + Vec<( + u32, + String, + u32, + ::std::collections::HashMap>>, + )>, + tree::MethodErr, + >; + fn local_credentials(&self) -> Result<(String, String), tree::MethodErr>; + fn stunservers(&self) -> Result, tree::MethodErr>; + fn relay_info( + &self, + ) -> Result< + Vec<::std::collections::HashMap>>>, + tree::MethodErr, + >; + fn has_server_info(&self) -> Result; + fn endpoints(&self) -> Result>, tree::MethodErr>; + fn icerestart_pending(&self) -> Result; +} + +pub fn call1_stream_interface_media_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + D::Signal: Default, + T: Call1StreamInterfaceMedia, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface( + "org.freedesktop.Telepathy.Call1.Stream.Interface.Media", + data, + ); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let state: u32 = i.read()?; + let d = fclone(minfo); + d.complete_sending_state_change(state)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("CompleteSendingStateChange", Default::default(), h); + let m = m.in_arg(("State", "u")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let reason: u32 = i.read()?; + let error: &str = i.read()?; + let message: &str = i.read()?; + let d = fclone(minfo); + d.report_sending_failure(reason, error, message)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("ReportSendingFailure", Default::default(), h); + let m = m.in_arg(("Reason", "u")); + let m = m.in_arg(("Error", "s")); + let m = m.in_arg(("Message", "s")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let state: u32 = i.read()?; + let d = fclone(minfo); + d.complete_receiving_state_change(state)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("CompleteReceivingStateChange", Default::default(), h); + let m = m.in_arg(("State", "u")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let reason: u32 = i.read()?; + let error: &str = i.read()?; + let message: &str = i.read()?; + let d = fclone(minfo); + d.report_receiving_failure(reason, error, message)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("ReportReceivingFailure", Default::default(), h); + let m = m.in_arg(("Reason", "u")); + let m = m.in_arg(("Error", "s")); + let m = m.in_arg(("Message", "s")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let username: &str = i.read()?; + let password: &str = i.read()?; + let d = fclone(minfo); + d.set_credentials(username, password)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("SetCredentials", Default::default(), h); + let m = m.in_arg(("Username", "s")); + let m = m.in_arg(("Password", "s")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let candidates: Vec<( + u32, + &str, + u32, + ::std::collections::HashMap<&str, arg::Variant>>, + )> = i.read()?; + let d = fclone(minfo); + d.add_candidates(candidates)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("AddCandidates", Default::default(), h); + let m = m.in_arg(("Candidates", "a(usua{sv})")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let d = fclone(minfo); + d.finish_initial_candidates()?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("FinishInitialCandidates", Default::default(), h); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let reason: (u32, u32, &str, &str) = i.read()?; + let d = fclone(minfo); + d.fail(reason)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("Fail", Default::default(), h); + let m = m.in_arg(("Reason", "(uuss)")); + let i = i.add_m(m); + + let p = factory.property::("SendingState", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.sending_state()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("ReceivingState", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.receiving_state()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("Transport", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.transport()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::>>, + )>, _>("LocalCandidates", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.local_candidates()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::<(&str, &str), _>("LocalCredentials", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.local_credentials()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::, _>("STUNServers", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.stunservers()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory + .property::>>>, _>( + "RelayInfo", + Default::default(), + ); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.relay_info()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("HasServerInfo", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.has_server_info()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::, _>("Endpoints", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.endpoints()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("ICERestartPending", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.icerestart_pending()?); + Ok(()) + }); + let i = i.add_p(p); + let s = factory.signal("SendingStateChanged", Default::default()); + let s = s.arg(("State", "u")); + let i = i.add_s(s); + let s = factory.signal("ReceivingStateChanged", Default::default()); + let s = s.arg(("State", "u")); + let i = i.add_s(s); + let s = factory.signal("LocalCandidatesAdded", Default::default()); + let s = s.arg(("Candidates", "a(usua{sv})")); + let i = i.add_s(s); + let s = factory.signal("LocalCredentialsChanged", Default::default()); + let s = s.arg(("Username", "s")); + let s = s.arg(("Password", "s")); + let i = i.add_s(s); + let s = factory.signal("RelayInfoChanged", Default::default()); + let s = s.arg(("Relay_Info", "aa{sv}")); + let i = i.add_s(s); + let s = factory.signal("STUNServersChanged", Default::default()); + let s = s.arg(("Servers", "a(sq)")); + let i = i.add_s(s); + let s = factory.signal("ServerInfoRetrieved", Default::default()); + let i = i.add_s(s); + let s = factory.signal("EndpointsChanged", Default::default()); + let s = s.arg(("Endpoints_Added", "ao")); + let s = s.arg(("Endpoints_Removed", "ao")); + let i = i.add_s(s); + let s = factory.signal("ICERestartRequested", Default::default()); + let i = i.add_s(s); + i +} + +#[derive(Debug)] +pub struct Call1StreamInterfaceMediaSendingStateChanged { + pub state: u32, +} + +impl arg::AppendAll for Call1StreamInterfaceMediaSendingStateChanged { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.state, i); + } +} + +impl arg::ReadAll for Call1StreamInterfaceMediaSendingStateChanged { + fn read(i: &mut arg::Iter) -> Result { + Ok(Call1StreamInterfaceMediaSendingStateChanged { state: i.read()? }) + } +} + +impl dbus::message::SignalArgs for Call1StreamInterfaceMediaSendingStateChanged { + const NAME: &'static str = "SendingStateChanged"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Stream.Interface.Media"; +} + +#[derive(Debug)] +pub struct Call1StreamInterfaceMediaReceivingStateChanged { + pub state: u32, +} + +impl arg::AppendAll for Call1StreamInterfaceMediaReceivingStateChanged { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.state, i); + } +} + +impl arg::ReadAll for Call1StreamInterfaceMediaReceivingStateChanged { + fn read(i: &mut arg::Iter) -> Result { + Ok(Call1StreamInterfaceMediaReceivingStateChanged { state: i.read()? }) + } +} + +impl dbus::message::SignalArgs for Call1StreamInterfaceMediaReceivingStateChanged { + const NAME: &'static str = "ReceivingStateChanged"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Stream.Interface.Media"; +} + +#[derive(Debug)] +pub struct Call1StreamInterfaceMediaLocalCandidatesAdded { + pub candidates: Vec<( + u32, + String, + u32, + ::std::collections::HashMap>>, + )>, +} + +impl arg::AppendAll for Call1StreamInterfaceMediaLocalCandidatesAdded { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.candidates, i); + } +} + +impl arg::ReadAll for Call1StreamInterfaceMediaLocalCandidatesAdded { + fn read(i: &mut arg::Iter) -> Result { + Ok(Call1StreamInterfaceMediaLocalCandidatesAdded { + candidates: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for Call1StreamInterfaceMediaLocalCandidatesAdded { + const NAME: &'static str = "LocalCandidatesAdded"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Stream.Interface.Media"; +} + +#[derive(Debug)] +pub struct Call1StreamInterfaceMediaLocalCredentialsChanged { + pub username: String, + pub password: String, +} + +impl arg::AppendAll for Call1StreamInterfaceMediaLocalCredentialsChanged { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.username, i); + arg::RefArg::append(&self.password, i); + } +} + +impl arg::ReadAll for Call1StreamInterfaceMediaLocalCredentialsChanged { + fn read(i: &mut arg::Iter) -> Result { + Ok(Call1StreamInterfaceMediaLocalCredentialsChanged { + username: i.read()?, + password: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for Call1StreamInterfaceMediaLocalCredentialsChanged { + const NAME: &'static str = "LocalCredentialsChanged"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Stream.Interface.Media"; +} + +#[derive(Debug)] +pub struct Call1StreamInterfaceMediaRelayInfoChanged { + pub relay_info: + Vec<::std::collections::HashMap>>>, +} + +impl arg::AppendAll for Call1StreamInterfaceMediaRelayInfoChanged { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.relay_info, i); + } +} + +impl arg::ReadAll for Call1StreamInterfaceMediaRelayInfoChanged { + fn read(i: &mut arg::Iter) -> Result { + Ok(Call1StreamInterfaceMediaRelayInfoChanged { + relay_info: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for Call1StreamInterfaceMediaRelayInfoChanged { + const NAME: &'static str = "RelayInfoChanged"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Stream.Interface.Media"; +} + +#[derive(Debug)] +pub struct Call1StreamInterfaceMediaSTUNServersChanged { + pub servers: Vec<(String, u16)>, +} + +impl arg::AppendAll for Call1StreamInterfaceMediaSTUNServersChanged { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.servers, i); + } +} + +impl arg::ReadAll for Call1StreamInterfaceMediaSTUNServersChanged { + fn read(i: &mut arg::Iter) -> Result { + Ok(Call1StreamInterfaceMediaSTUNServersChanged { servers: i.read()? }) + } +} + +impl dbus::message::SignalArgs for Call1StreamInterfaceMediaSTUNServersChanged { + const NAME: &'static str = "STUNServersChanged"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Stream.Interface.Media"; +} + +#[derive(Debug)] +pub struct Call1StreamInterfaceMediaServerInfoRetrieved {} + +impl arg::AppendAll for Call1StreamInterfaceMediaServerInfoRetrieved { + fn append(&self, _: &mut arg::IterAppend) {} +} + +impl arg::ReadAll for Call1StreamInterfaceMediaServerInfoRetrieved { + fn read(_: &mut arg::Iter) -> Result { + Ok(Call1StreamInterfaceMediaServerInfoRetrieved {}) + } +} + +impl dbus::message::SignalArgs for Call1StreamInterfaceMediaServerInfoRetrieved { + const NAME: &'static str = "ServerInfoRetrieved"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Stream.Interface.Media"; +} + +#[derive(Debug)] +pub struct Call1StreamInterfaceMediaEndpointsChanged { + pub endpoints_added: Vec>, + pub endpoints_removed: Vec>, +} + +impl arg::AppendAll for Call1StreamInterfaceMediaEndpointsChanged { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.endpoints_added, i); + arg::RefArg::append(&self.endpoints_removed, i); + } +} + +impl arg::ReadAll for Call1StreamInterfaceMediaEndpointsChanged { + fn read(i: &mut arg::Iter) -> Result { + Ok(Call1StreamInterfaceMediaEndpointsChanged { + endpoints_added: i.read()?, + endpoints_removed: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for Call1StreamInterfaceMediaEndpointsChanged { + const NAME: &'static str = "EndpointsChanged"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Stream.Interface.Media"; +} + +#[derive(Debug)] +pub struct Call1StreamInterfaceMediaICERestartRequested {} + +impl arg::AppendAll for Call1StreamInterfaceMediaICERestartRequested { + fn append(&self, _: &mut arg::IterAppend) {} +} + +impl arg::ReadAll for Call1StreamInterfaceMediaICERestartRequested { + fn read(_: &mut arg::Iter) -> Result { + Ok(Call1StreamInterfaceMediaICERestartRequested {}) + } +} + +impl dbus::message::SignalArgs for Call1StreamInterfaceMediaICERestartRequested { + const NAME: &'static str = "ICERestartRequested"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Stream.Interface.Media"; +} diff --git a/src/telepathy/channel.rs b/src/telepathy/channel.rs new file mode 100644 index 0000000..eaca799 --- /dev/null +++ b/src/telepathy/channel.rs @@ -0,0 +1,192 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel.xml -i org.freedesktop.Telepathy -o src/telepathy/channel.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait Channel { + fn close(&self) -> Result<(), tree::MethodErr>; + fn get_channel_type(&self) -> Result; + fn get_handle(&self) -> Result<(u32, u32), tree::MethodErr>; + fn get_interfaces(&self) -> Result, tree::MethodErr>; + fn channel_type(&self) -> Result; + fn interfaces(&self) -> Result, tree::MethodErr>; + fn target_handle(&self) -> Result; + fn target_id(&self) -> Result; + fn target_handle_type(&self) -> Result; + fn requested(&self) -> Result; + fn initiator_handle(&self) -> Result; + fn initiator_id(&self) -> Result; +} + +pub fn channel_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + D::Signal: Default, + T: Channel, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface("org.freedesktop.Telepathy.Channel", data); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let d = fclone(minfo); + d.close()?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("Close", Default::default(), h); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let d = fclone(minfo); + let channel_type = d.get_channel_type()?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(channel_type); + Ok(vec![rm]) + }; + let m = factory.method("GetChannelType", Default::default(), h); + let m = m.out_arg(("Channel_Type", "s")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let d = fclone(minfo); + let (target_handle_type, target_handle) = d.get_handle()?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(target_handle_type); + let rm = rm.append1(target_handle); + Ok(vec![rm]) + }; + let m = factory.method("GetHandle", Default::default(), h); + let m = m.out_arg(("Target_Handle_Type", "u")); + let m = m.out_arg(("Target_Handle", "u")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let d = fclone(minfo); + let interfaces = d.get_interfaces()?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(interfaces); + Ok(vec![rm]) + }; + let m = factory.method("GetInterfaces", Default::default(), h); + let m = m.out_arg(("Interfaces", "as")); + let i = i.add_m(m); + + let p = factory.property::<&str, _>("ChannelType", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.channel_type()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::, _>("Interfaces", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.interfaces()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("TargetHandle", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.target_handle()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::<&str, _>("TargetID", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.target_id()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("TargetHandleType", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.target_handle_type()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("Requested", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.requested()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("InitiatorHandle", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.initiator_handle()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::<&str, _>("InitiatorID", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.initiator_id()?); + Ok(()) + }); + let i = i.add_p(p); + let s = factory.signal("Closed", Default::default()); + let i = i.add_s(s); + i +} + +#[derive(Debug)] +pub struct ChannelClosed {} + +impl arg::AppendAll for ChannelClosed { + fn append(&self, _: &mut arg::IterAppend) {} +} + +impl arg::ReadAll for ChannelClosed { + fn read(_: &mut arg::Iter) -> Result { + Ok(ChannelClosed {}) + } +} + +impl dbus::message::SignalArgs for ChannelClosed { + const NAME: &'static str = "Closed"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel"; +} diff --git a/src/telepathy/channel_bundle.rs b/src/telepathy/channel_bundle.rs new file mode 100644 index 0000000..4ceb729 --- /dev/null +++ b/src/telepathy/channel_bundle.rs @@ -0,0 +1,35 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Bundle.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_bundle.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ChannelBundleDRAFT { + fn interfaces(&self) -> Result, tree::MethodErr>; +} + +pub fn channel_bundle_draft_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + T: ChannelBundleDRAFT, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface("org.freedesktop.Telepathy.ChannelBundle.DRAFT", data); + let f = ::std::sync::Arc::new(f); + let p = factory.property::, _>("Interfaces", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.interfaces()?); + Ok(()) + }); + let i = i.add_p(p); + i +} diff --git a/src/telepathy/channel_dispatch_operation.rs b/src/telepathy/channel_dispatch_operation.rs new file mode 100644 index 0000000..9ec805d --- /dev/null +++ b/src/telepathy/channel_dispatch_operation.rs @@ -0,0 +1,192 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Dispatch_Operation.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_dispatch_operation.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ChannelDispatchOperation { + fn handle_with(&self, handler: &str) -> Result<(), tree::MethodErr>; + fn claim(&self) -> Result<(), tree::MethodErr>; + fn handle_with_time(&self, handler: &str, user_action_time: i64) + -> Result<(), tree::MethodErr>; + fn interfaces(&self) -> Result, tree::MethodErr>; + fn connection(&self) -> Result, tree::MethodErr>; + fn account(&self) -> Result, tree::MethodErr>; + fn channels( + &self, + ) -> Result< + Vec<( + dbus::Path<'static>, + ::std::collections::HashMap>>, + )>, + tree::MethodErr, + >; + fn possible_handlers(&self) -> Result, tree::MethodErr>; +} + +pub fn channel_dispatch_operation_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + D::Signal: Default, + T: ChannelDispatchOperation, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface("org.freedesktop.Telepathy.ChannelDispatchOperation", data); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let handler: &str = i.read()?; + let d = fclone(minfo); + d.handle_with(handler)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("HandleWith", Default::default(), h); + let m = m.in_arg(("Handler", "s")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let d = fclone(minfo); + d.claim()?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("Claim", Default::default(), h); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let handler: &str = i.read()?; + let user_action_time: i64 = i.read()?; + let d = fclone(minfo); + d.handle_with_time(handler, user_action_time)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("HandleWithTime", Default::default(), h); + let m = m.in_arg(("Handler", "s")); + let m = m.in_arg(("UserActionTime", "x")); + let i = i.add_m(m); + + let p = factory.property::, _>("Interfaces", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.interfaces()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("Connection", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.connection()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("Account", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.account()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::>>, + )>, _>("Channels", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.channels()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::, _>("PossibleHandlers", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.possible_handlers()?); + Ok(()) + }); + let i = i.add_p(p); + let s = factory.signal("ChannelLost", Default::default()); + let s = s.arg(("Channel", "o")); + let s = s.arg(("Error", "s")); + let s = s.arg(("Message", "s")); + let i = i.add_s(s); + let s = factory.signal("Finished", Default::default()); + let i = i.add_s(s); + i +} + +#[derive(Debug)] +pub struct ChannelDispatchOperationChannelLost { + pub channel: dbus::Path<'static>, + pub error: String, + pub message: String, +} + +impl arg::AppendAll for ChannelDispatchOperationChannelLost { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.channel, i); + arg::RefArg::append(&self.error, i); + arg::RefArg::append(&self.message, i); + } +} + +impl arg::ReadAll for ChannelDispatchOperationChannelLost { + fn read(i: &mut arg::Iter) -> Result { + Ok(ChannelDispatchOperationChannelLost { + channel: i.read()?, + error: i.read()?, + message: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for ChannelDispatchOperationChannelLost { + const NAME: &'static str = "ChannelLost"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.ChannelDispatchOperation"; +} + +#[derive(Debug)] +pub struct ChannelDispatchOperationFinished {} + +impl arg::AppendAll for ChannelDispatchOperationFinished { + fn append(&self, _: &mut arg::IterAppend) {} +} + +impl arg::ReadAll for ChannelDispatchOperationFinished { + fn read(_: &mut arg::Iter) -> Result { + Ok(ChannelDispatchOperationFinished {}) + } +} + +impl dbus::message::SignalArgs for ChannelDispatchOperationFinished { + const NAME: &'static str = "Finished"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.ChannelDispatchOperation"; +} diff --git a/src/telepathy/channel_dispatcher.rs b/src/telepathy/channel_dispatcher.rs new file mode 100644 index 0000000..556adda --- /dev/null +++ b/src/telepathy/channel_dispatcher.rs @@ -0,0 +1,255 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Dispatcher.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_dispatcher.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ChannelDispatcher { + fn create_channel( + &self, + account: dbus::Path, + requested_properties: ::std::collections::HashMap<&str, arg::Variant>>, + user_action_time: i64, + preferred_handler: &str, + ) -> Result, tree::MethodErr>; + fn ensure_channel( + &self, + account: dbus::Path, + requested_properties: ::std::collections::HashMap<&str, arg::Variant>>, + user_action_time: i64, + preferred_handler: &str, + ) -> Result, tree::MethodErr>; + fn create_channel_with_hints( + &self, + account: dbus::Path, + requested_properties: ::std::collections::HashMap<&str, arg::Variant>>, + user_action_time: i64, + preferred_handler: &str, + hints: ::std::collections::HashMap<&str, arg::Variant>>, + ) -> Result, tree::MethodErr>; + fn ensure_channel_with_hints( + &self, + account: dbus::Path, + requested_properties: ::std::collections::HashMap<&str, arg::Variant>>, + user_action_time: i64, + preferred_handler: &str, + hints: ::std::collections::HashMap<&str, arg::Variant>>, + ) -> Result, tree::MethodErr>; + fn delegate_channels( + &self, + channels: Vec, + user_action_time: i64, + preferred_handler: &str, + ) -> Result< + ( + Vec>, + ::std::collections::HashMap, (String, String)>, + ), + tree::MethodErr, + >; + fn present_channel( + &self, + channel: dbus::Path, + user_action_time: i64, + ) -> Result<(), tree::MethodErr>; + fn interfaces(&self) -> Result, tree::MethodErr>; + fn supports_request_hints(&self) -> Result; +} + +pub fn channel_dispatcher_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + T: ChannelDispatcher, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface("org.freedesktop.Telepathy.ChannelDispatcher", data); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let account: dbus::Path = i.read()?; + let requested_properties: ::std::collections::HashMap< + &str, + arg::Variant>, + > = i.read()?; + let user_action_time: i64 = i.read()?; + let preferred_handler: &str = i.read()?; + let d = fclone(minfo); + let request = d.create_channel( + account, + requested_properties, + user_action_time, + preferred_handler, + )?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(request); + Ok(vec![rm]) + }; + let m = factory.method("CreateChannel", Default::default(), h); + let m = m.in_arg(("Account", "o")); + let m = m.in_arg(("Requested_Properties", "a{sv}")); + let m = m.in_arg(("User_Action_Time", "x")); + let m = m.in_arg(("Preferred_Handler", "s")); + let m = m.out_arg(("Request", "o")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let account: dbus::Path = i.read()?; + let requested_properties: ::std::collections::HashMap< + &str, + arg::Variant>, + > = i.read()?; + let user_action_time: i64 = i.read()?; + let preferred_handler: &str = i.read()?; + let d = fclone(minfo); + let request = d.ensure_channel( + account, + requested_properties, + user_action_time, + preferred_handler, + )?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(request); + Ok(vec![rm]) + }; + let m = factory.method("EnsureChannel", Default::default(), h); + let m = m.in_arg(("Account", "o")); + let m = m.in_arg(("Requested_Properties", "a{sv}")); + let m = m.in_arg(("User_Action_Time", "x")); + let m = m.in_arg(("Preferred_Handler", "s")); + let m = m.out_arg(("Request", "o")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let account: dbus::Path = i.read()?; + let requested_properties: ::std::collections::HashMap< + &str, + arg::Variant>, + > = i.read()?; + let user_action_time: i64 = i.read()?; + let preferred_handler: &str = i.read()?; + let hints: ::std::collections::HashMap<&str, arg::Variant>> = + i.read()?; + let d = fclone(minfo); + let request = d.create_channel_with_hints( + account, + requested_properties, + user_action_time, + preferred_handler, + hints, + )?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(request); + Ok(vec![rm]) + }; + let m = factory.method("CreateChannelWithHints", Default::default(), h); + let m = m.in_arg(("Account", "o")); + let m = m.in_arg(("Requested_Properties", "a{sv}")); + let m = m.in_arg(("User_Action_Time", "x")); + let m = m.in_arg(("Preferred_Handler", "s")); + let m = m.in_arg(("Hints", "a{sv}")); + let m = m.out_arg(("Request", "o")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let account: dbus::Path = i.read()?; + let requested_properties: ::std::collections::HashMap< + &str, + arg::Variant>, + > = i.read()?; + let user_action_time: i64 = i.read()?; + let preferred_handler: &str = i.read()?; + let hints: ::std::collections::HashMap<&str, arg::Variant>> = + i.read()?; + let d = fclone(minfo); + let request = d.ensure_channel_with_hints( + account, + requested_properties, + user_action_time, + preferred_handler, + hints, + )?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(request); + Ok(vec![rm]) + }; + let m = factory.method("EnsureChannelWithHints", Default::default(), h); + let m = m.in_arg(("Account", "o")); + let m = m.in_arg(("Requested_Properties", "a{sv}")); + let m = m.in_arg(("User_Action_Time", "x")); + let m = m.in_arg(("Preferred_Handler", "s")); + let m = m.in_arg(("Hints", "a{sv}")); + let m = m.out_arg(("Request", "o")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let channels: Vec = i.read()?; + let user_action_time: i64 = i.read()?; + let preferred_handler: &str = i.read()?; + let d = fclone(minfo); + let (delegated, not_delegated) = + d.delegate_channels(channels, user_action_time, preferred_handler)?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(delegated); + let rm = rm.append1(not_delegated); + Ok(vec![rm]) + }; + let m = factory.method("DelegateChannels", Default::default(), h); + let m = m.in_arg(("Channels", "ao")); + let m = m.in_arg(("User_Action_Time", "x")); + let m = m.in_arg(("Preferred_Handler", "s")); + let m = m.out_arg(("Delegated", "ao")); + let m = m.out_arg(("Not_Delegated", "a{o(ss)}")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let channel: dbus::Path = i.read()?; + let user_action_time: i64 = i.read()?; + let d = fclone(minfo); + d.present_channel(channel, user_action_time)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("PresentChannel", Default::default(), h); + let m = m.in_arg(("Channel", "o")); + let m = m.in_arg(("User_Action_Time", "x")); + let i = i.add_m(m); + + let p = factory.property::, _>("Interfaces", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.interfaces()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("SupportsRequestHints", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.supports_request_hints()?); + Ok(()) + }); + let i = i.add_p(p); + i +} diff --git a/src/telepathy/channel_dispatcher_interface_messages1.rs b/src/telepathy/channel_dispatcher_interface_messages1.rs new file mode 100644 index 0000000..673bd14 --- /dev/null +++ b/src/telepathy/channel_dispatcher_interface_messages1.rs @@ -0,0 +1,54 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Dispatcher_Interface_Messages1.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_dispatcher_interface_messages1.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ChannelDispatcherInterfaceMessages1 { + fn send_message( + &self, + account: dbus::Path, + target_id: &str, + message: Vec<::std::collections::HashMap<&str, arg::Variant>>>, + flags: u32, + ) -> Result; +} + +pub fn channel_dispatcher_interface_messages1_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + T: ChannelDispatcherInterfaceMessages1, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface( + "org.freedesktop.Telepathy.ChannelDispatcher.Interface.Messages1", + data, + ); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let account: dbus::Path = i.read()?; + let target_id: &str = i.read()?; + let message: Vec<::std::collections::HashMap<&str, arg::Variant>>> = + i.read()?; + let flags: u32 = i.read()?; + let d = fclone(minfo); + let token = d.send_message(account, target_id, message, flags)?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(token); + Ok(vec![rm]) + }; + let m = factory.method("SendMessage", Default::default(), h); + let m = m.in_arg(("Account", "o")); + let m = m.in_arg(("Target_ID", "s")); + let m = m.in_arg(("Message", "aa{sv}")); + let m = m.in_arg(("Flags", "u")); + let m = m.out_arg(("Token", "s")); + let i = i.add_m(m); + i +} diff --git a/src/telepathy/channel_dispatcher_interface_operation_list.rs b/src/telepathy/channel_dispatcher_interface_operation_list.rs new file mode 100644 index 0000000..ddb460f --- /dev/null +++ b/src/telepathy/channel_dispatcher_interface_operation_list.rs @@ -0,0 +1,117 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Dispatcher_Interface_Operation_List.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_dispatcher_interface_operation_list.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ChannelDispatcherInterfaceOperationList { + fn dispatch_operations( + &self, + ) -> Result< + Vec<( + dbus::Path<'static>, + ::std::collections::HashMap>>, + )>, + tree::MethodErr, + >; +} + +pub fn channel_dispatcher_interface_operation_list_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + D::Signal: Default, + T: ChannelDispatcherInterfaceOperationList, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface( + "org.freedesktop.Telepathy.ChannelDispatcher.Interface.OperationList", + data, + ); + let f = ::std::sync::Arc::new(f); + let p = factory.property::>>, + )>, _>("DispatchOperations", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.dispatch_operations()?); + Ok(()) + }); + let i = i.add_p(p); + let s = factory.signal("NewDispatchOperation", Default::default()); + let s = s.arg(("Dispatch_Operation", "o")); + let s = s.arg(("Properties", "a{sv}")); + let i = i.add_s(s); + let s = factory.signal("DispatchOperationFinished", Default::default()); + let s = s.arg(("Dispatch_Operation", "o")); + let i = i.add_s(s); + i +} + +#[derive(Debug)] +pub struct ChannelDispatcherInterfaceOperationListNewDispatchOperation { + pub dispatch_operation: dbus::Path<'static>, + pub properties: + ::std::collections::HashMap>>, +} + +impl arg::AppendAll for ChannelDispatcherInterfaceOperationListNewDispatchOperation { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.dispatch_operation, i); + arg::RefArg::append(&self.properties, i); + } +} + +impl arg::ReadAll for ChannelDispatcherInterfaceOperationListNewDispatchOperation { + fn read(i: &mut arg::Iter) -> Result { + Ok( + ChannelDispatcherInterfaceOperationListNewDispatchOperation { + dispatch_operation: i.read()?, + properties: i.read()?, + }, + ) + } +} + +impl dbus::message::SignalArgs for ChannelDispatcherInterfaceOperationListNewDispatchOperation { + const NAME: &'static str = "NewDispatchOperation"; + const INTERFACE: &'static str = + "org.freedesktop.Telepathy.ChannelDispatcher.Interface.OperationList"; +} + +#[derive(Debug)] +pub struct ChannelDispatcherInterfaceOperationListDispatchOperationFinished { + pub dispatch_operation: dbus::Path<'static>, +} + +impl arg::AppendAll for ChannelDispatcherInterfaceOperationListDispatchOperationFinished { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.dispatch_operation, i); + } +} + +impl arg::ReadAll for ChannelDispatcherInterfaceOperationListDispatchOperationFinished { + fn read(i: &mut arg::Iter) -> Result { + Ok( + ChannelDispatcherInterfaceOperationListDispatchOperationFinished { + dispatch_operation: i.read()?, + }, + ) + } +} + +impl dbus::message::SignalArgs + for ChannelDispatcherInterfaceOperationListDispatchOperationFinished +{ + const NAME: &'static str = "DispatchOperationFinished"; + const INTERFACE: &'static str = + "org.freedesktop.Telepathy.ChannelDispatcher.Interface.OperationList"; +} diff --git a/src/telepathy/channel_future.rs b/src/telepathy/channel_future.rs new file mode 100644 index 0000000..bd50181 --- /dev/null +++ b/src/telepathy/channel_future.rs @@ -0,0 +1,35 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Future.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_future.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ChannelFUTURE { + fn bundle(&self) -> Result, tree::MethodErr>; +} + +pub fn channel_future_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + T: ChannelFUTURE, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface("org.freedesktop.Telepathy.Channel.FUTURE", data); + let f = ::std::sync::Arc::new(f); + let p = factory.property::("Bundle", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.bundle()?); + Ok(()) + }); + let i = i.add_p(p); + i +} diff --git a/src/telepathy/channel_handler.rs b/src/telepathy/channel_handler.rs new file mode 100644 index 0000000..7d08f29 --- /dev/null +++ b/src/telepathy/channel_handler.rs @@ -0,0 +1,61 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Handler.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_handler.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ChannelHandler { + fn handle_channel( + &self, + bus_name: &str, + connection: dbus::Path, + channel_type: &str, + channel: dbus::Path, + handle_type: u32, + handle: u32, + ) -> Result<(), tree::MethodErr>; +} + +pub fn channel_handler_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + T: ChannelHandler, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface("org.freedesktop.Telepathy.ChannelHandler", data); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let bus_name: &str = i.read()?; + let connection: dbus::Path = i.read()?; + let channel_type: &str = i.read()?; + let channel: dbus::Path = i.read()?; + let handle_type: u32 = i.read()?; + let handle: u32 = i.read()?; + let d = fclone(minfo); + d.handle_channel( + bus_name, + connection, + channel_type, + channel, + handle_type, + handle, + )?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("HandleChannel", Default::default(), h); + let m = m.in_arg(("Bus_Name", "s")); + let m = m.in_arg(("Connection", "o")); + let m = m.in_arg(("Channel_Type", "s")); + let m = m.in_arg(("Channel", "o")); + let m = m.in_arg(("Handle_Type", "u")); + let m = m.in_arg(("Handle", "u")); + let i = i.add_m(m); + i +} diff --git a/src/telepathy/channel_interface_addressing.rs b/src/telepathy/channel_interface_addressing.rs new file mode 100644 index 0000000..d502ddf --- /dev/null +++ b/src/telepathy/channel_interface_addressing.rs @@ -0,0 +1,74 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_Addressing.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_interface_addressing.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ChannelInterfaceAddressing1 { + fn target_vcard_field(&self) -> Result; + fn target_urischeme(&self) -> Result; + fn target_vcard_address(&self) -> Result; + fn target_uri(&self) -> Result; +} + +pub fn channel_interface_addressing1_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + T: ChannelInterfaceAddressing1, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface( + "org.freedesktop.Telepathy.Channel.Interface.Addressing1", + data, + ); + let f = ::std::sync::Arc::new(f); + let p = factory.property::<&str, _>("TargetVCardField", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.target_vcard_field()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::<&str, _>("TargetURIScheme", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.target_urischeme()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::<&str, _>("TargetVCardAddress", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.target_vcard_address()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::<&str, _>("TargetURI", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.target_uri()?); + Ok(()) + }); + let i = i.add_p(p); + i +} diff --git a/src/telepathy/channel_interface_anonymity.rs b/src/telepathy/channel_interface_anonymity.rs new file mode 100644 index 0000000..5f64643 --- /dev/null +++ b/src/telepathy/channel_interface_anonymity.rs @@ -0,0 +1,62 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_Anonymity.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_interface_anonymity.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ChannelInterfaceAnonymity { + fn anonymity_modes(&self) -> Result; + fn anonymity_mandatory(&self) -> Result; + fn anonymous_id(&self) -> Result; +} + +pub fn channel_interface_anonymity_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + T: ChannelInterfaceAnonymity, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface( + "org.freedesktop.Telepathy.Channel.Interface.Anonymity", + data, + ); + let f = ::std::sync::Arc::new(f); + let p = factory.property::("AnonymityModes", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.anonymity_modes()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("AnonymityMandatory", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.anonymity_mandatory()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::<&str, _>("AnonymousID", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.anonymous_id()?); + Ok(()) + }); + let i = i.add_p(p); + i +} diff --git a/src/telepathy/channel_interface_call_state.rs b/src/telepathy/channel_interface_call_state.rs new file mode 100644 index 0000000..bffad9e --- /dev/null +++ b/src/telepathy/channel_interface_call_state.rs @@ -0,0 +1,70 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_Call_State.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_interface_call_state.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ChannelInterfaceCallState { + fn get_call_states(&self) -> Result<::std::collections::HashMap, tree::MethodErr>; +} + +pub fn channel_interface_call_state_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Signal: Default, + T: ChannelInterfaceCallState, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface( + "org.freedesktop.Telepathy.Channel.Interface.CallState", + data, + ); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let d = fclone(minfo); + let states = d.get_call_states()?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(states); + Ok(vec![rm]) + }; + let m = factory.method("GetCallStates", Default::default(), h); + let m = m.out_arg(("States", "a{uu}")); + let i = i.add_m(m); + let s = factory.signal("CallStateChanged", Default::default()); + let s = s.arg(("Contact", "u")); + let s = s.arg(("State", "u")); + let i = i.add_s(s); + i +} + +#[derive(Debug)] +pub struct ChannelInterfaceCallStateCallStateChanged { + pub contact: u32, + pub state: u32, +} + +impl arg::AppendAll for ChannelInterfaceCallStateCallStateChanged { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.contact, i); + arg::RefArg::append(&self.state, i); + } +} + +impl arg::ReadAll for ChannelInterfaceCallStateCallStateChanged { + fn read(i: &mut arg::Iter) -> Result { + Ok(ChannelInterfaceCallStateCallStateChanged { + contact: i.read()?, + state: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for ChannelInterfaceCallStateCallStateChanged { + const NAME: &'static str = "CallStateChanged"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Interface.CallState"; +} diff --git a/src/telepathy/channel_interface_captcha_authentication.rs b/src/telepathy/channel_interface_captcha_authentication.rs new file mode 100644 index 0000000..0312020 --- /dev/null +++ b/src/telepathy/channel_interface_captcha_authentication.rs @@ -0,0 +1,153 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_Captcha_Authentication.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_interface_captcha_authentication.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ChannelInterfaceCaptchaAuthentication1 { + fn get_captchas( + &self, + ) -> Result<(Vec<(u32, String, String, u32, Vec)>, u32, String), tree::MethodErr>; + fn get_captcha_data(&self, id: u32, mime_type: &str) -> Result, tree::MethodErr>; + fn answer_captchas( + &self, + answers: ::std::collections::HashMap, + ) -> Result<(), tree::MethodErr>; + fn cancel_captcha(&self, reason: u32, debug_message: &str) -> Result<(), tree::MethodErr>; + fn can_retry_captcha(&self) -> Result; + fn captcha_status(&self) -> Result; + fn captcha_error(&self) -> Result; + fn captcha_error_details( + &self, + ) -> Result< + ::std::collections::HashMap>>, + tree::MethodErr, + >; +} + +pub fn channel_interface_captcha_authentication1_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + T: ChannelInterfaceCaptchaAuthentication1, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface( + "org.freedesktop.Telepathy.Channel.Interface.CaptchaAuthentication1", + data, + ); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let d = fclone(minfo); + let (captcha_info, number_required, language) = d.get_captchas()?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(captcha_info); + let rm = rm.append1(number_required); + let rm = rm.append1(language); + Ok(vec![rm]) + }; + let m = factory.method("GetCaptchas", Default::default(), h); + let m = m.out_arg(("Captcha_Info", "a(ussuas)")); + let m = m.out_arg(("Number_Required", "u")); + let m = m.out_arg(("Language", "s")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let id: u32 = i.read()?; + let mime_type: &str = i.read()?; + let d = fclone(minfo); + let captcha_data = d.get_captcha_data(id, mime_type)?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(captcha_data); + Ok(vec![rm]) + }; + let m = factory.method("GetCaptchaData", Default::default(), h); + let m = m.in_arg(("ID", "u")); + let m = m.in_arg(("Mime_Type", "s")); + let m = m.out_arg(("Captcha_Data", "ay")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let answers: ::std::collections::HashMap = i.read()?; + let d = fclone(minfo); + d.answer_captchas(answers)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("AnswerCaptchas", Default::default(), h); + let m = m.in_arg(("Answers", "a{us}")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let reason: u32 = i.read()?; + let debug_message: &str = i.read()?; + let d = fclone(minfo); + d.cancel_captcha(reason, debug_message)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("CancelCaptcha", Default::default(), h); + let m = m.in_arg(("Reason", "u")); + let m = m.in_arg(("Debug_Message", "s")); + let i = i.add_m(m); + + let p = factory.property::("CanRetryCaptcha", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.can_retry_captcha()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("CaptchaStatus", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.captcha_status()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::<&str, _>("CaptchaError", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.captcha_error()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory + .property::<::std::collections::HashMap<&str, arg::Variant>>, _>( + "CaptchaErrorDetails", + Default::default(), + ); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.captcha_error_details()?); + Ok(()) + }); + let i = i.add_p(p); + i +} diff --git a/src/telepathy/channel_interface_chat_state.rs b/src/telepathy/channel_interface_chat_state.rs new file mode 100644 index 0000000..325a045 --- /dev/null +++ b/src/telepathy/channel_interface_chat_state.rs @@ -0,0 +1,85 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_Chat_State.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_interface_chat_state.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ChannelInterfaceChatState { + fn set_chat_state(&self, state: u32) -> Result<(), tree::MethodErr>; + fn chat_states(&self) -> Result<::std::collections::HashMap, tree::MethodErr>; +} + +pub fn channel_interface_chat_state_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + D::Signal: Default, + T: ChannelInterfaceChatState, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface( + "org.freedesktop.Telepathy.Channel.Interface.ChatState", + data, + ); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let state: u32 = i.read()?; + let d = fclone(minfo); + d.set_chat_state(state)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("SetChatState", Default::default(), h); + let m = m.in_arg(("State", "u")); + let i = i.add_m(m); + + let p = factory + .property::<::std::collections::HashMap, _>("ChatStates", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.chat_states()?); + Ok(()) + }); + let i = i.add_p(p); + let s = factory.signal("ChatStateChanged", Default::default()); + let s = s.arg(("Contact", "u")); + let s = s.arg(("State", "u")); + let i = i.add_s(s); + i +} + +#[derive(Debug)] +pub struct ChannelInterfaceChatStateChatStateChanged { + pub contact: u32, + pub state: u32, +} + +impl arg::AppendAll for ChannelInterfaceChatStateChatStateChanged { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.contact, i); + arg::RefArg::append(&self.state, i); + } +} + +impl arg::ReadAll for ChannelInterfaceChatStateChatStateChanged { + fn read(i: &mut arg::Iter) -> Result { + Ok(ChannelInterfaceChatStateChatStateChanged { + contact: i.read()?, + state: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for ChannelInterfaceChatStateChatStateChanged { + const NAME: &'static str = "ChatStateChanged"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Interface.ChatState"; +} diff --git a/src/telepathy/channel_interface_conference.rs b/src/telepathy/channel_interface_conference.rs new file mode 100644 index 0000000..b210a55 --- /dev/null +++ b/src/telepathy/channel_interface_conference.rs @@ -0,0 +1,171 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_Conference.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_interface_conference.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ChannelInterfaceConference { + fn channels(&self) -> Result>, tree::MethodErr>; + fn initial_channels(&self) -> Result>, tree::MethodErr>; + fn initial_invitee_handles(&self) -> Result, tree::MethodErr>; + fn initial_invitee_ids(&self) -> Result, tree::MethodErr>; + fn invitation_message(&self) -> Result; + fn original_channels( + &self, + ) -> Result<::std::collections::HashMap>, tree::MethodErr>; +} + +pub fn channel_interface_conference_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + D::Signal: Default, + T: ChannelInterfaceConference, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface( + "org.freedesktop.Telepathy.Channel.Interface.Conference", + data, + ); + let f = ::std::sync::Arc::new(f); + let p = factory.property::, _>("Channels", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.channels()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::, _>("InitialChannels", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.initial_channels()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::, _>("InitialInviteeHandles", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.initial_invitee_handles()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::, _>("InitialInviteeIDs", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.initial_invitee_ids()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::<&str, _>("InvitationMessage", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.invitation_message()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::<::std::collections::HashMap, _>( + "OriginalChannels", + Default::default(), + ); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.original_channels()?); + Ok(()) + }); + let i = i.add_p(p); + let s = factory.signal("ChannelMerged", Default::default()); + let s = s.arg(("Channel", "o")); + let s = s.arg(("Channel_Specific_Handle", "u")); + let s = s.arg(("Properties", "a{sv}")); + let i = i.add_s(s); + let s = factory.signal("ChannelRemoved", Default::default()); + let s = s.arg(("Channel", "o")); + let s = s.arg(("Details", "a{sv}")); + let i = i.add_s(s); + i +} + +#[derive(Debug)] +pub struct ChannelInterfaceConferenceChannelMerged { + pub channel: dbus::Path<'static>, + pub channel_specific_handle: u32, + pub properties: + ::std::collections::HashMap>>, +} + +impl arg::AppendAll for ChannelInterfaceConferenceChannelMerged { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.channel, i); + arg::RefArg::append(&self.channel_specific_handle, i); + arg::RefArg::append(&self.properties, i); + } +} + +impl arg::ReadAll for ChannelInterfaceConferenceChannelMerged { + fn read(i: &mut arg::Iter) -> Result { + Ok(ChannelInterfaceConferenceChannelMerged { + channel: i.read()?, + channel_specific_handle: i.read()?, + properties: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for ChannelInterfaceConferenceChannelMerged { + const NAME: &'static str = "ChannelMerged"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Interface.Conference"; +} + +#[derive(Debug)] +pub struct ChannelInterfaceConferenceChannelRemoved { + pub channel: dbus::Path<'static>, + pub details: ::std::collections::HashMap>>, +} + +impl arg::AppendAll for ChannelInterfaceConferenceChannelRemoved { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.channel, i); + arg::RefArg::append(&self.details, i); + } +} + +impl arg::ReadAll for ChannelInterfaceConferenceChannelRemoved { + fn read(i: &mut arg::Iter) -> Result { + Ok(ChannelInterfaceConferenceChannelRemoved { + channel: i.read()?, + details: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for ChannelInterfaceConferenceChannelRemoved { + const NAME: &'static str = "ChannelRemoved"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Interface.Conference"; +} diff --git a/src/telepathy/channel_interface_credentials_storage.rs b/src/telepathy/channel_interface_credentials_storage.rs new file mode 100644 index 0000000..8e9639b --- /dev/null +++ b/src/telepathy/channel_interface_credentials_storage.rs @@ -0,0 +1,39 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_Credentials_Storage.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_interface_credentials_storage.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ChannelInterfaceCredentialsStorageDRAFT { + fn store_credentials(&self, store: bool) -> Result<(), tree::MethodErr>; +} + +pub fn channel_interface_credentials_storage_draft_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + T: ChannelInterfaceCredentialsStorageDRAFT, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface( + "org.freedesktop.Telepathy.Channel.Interface.CredentialsStorage.DRAFT", + data, + ); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let store: bool = i.read()?; + let d = fclone(minfo); + d.store_credentials(store)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("StoreCredentials", Default::default(), h); + let m = m.in_arg(("Store", "b")); + let i = i.add_m(m); + i +} diff --git a/src/telepathy/channel_interface_destroyable.rs b/src/telepathy/channel_interface_destroyable.rs new file mode 100644 index 0000000..16eb819 --- /dev/null +++ b/src/telepathy/channel_interface_destroyable.rs @@ -0,0 +1,36 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_Destroyable.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_interface_destroyable.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ChannelInterfaceDestroyable { + fn destroy(&self) -> Result<(), tree::MethodErr>; +} + +pub fn channel_interface_destroyable_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + T: ChannelInterfaceDestroyable, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface( + "org.freedesktop.Telepathy.Channel.Interface.Destroyable", + data, + ); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let d = fclone(minfo); + d.destroy()?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("Destroy", Default::default(), h); + let i = i.add_m(m); + i +} diff --git a/src/telepathy/channel_interface_dtmf.rs b/src/telepathy/channel_interface_dtmf.rs new file mode 100644 index 0000000..84f3f9e --- /dev/null +++ b/src/telepathy/channel_interface_dtmf.rs @@ -0,0 +1,181 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_DTMF.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_interface_dtmf.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ChannelInterfaceDTMF { + fn start_tone(&self, stream_id: u32, event: u8) -> Result<(), tree::MethodErr>; + fn stop_tone(&self, stream_id: u32) -> Result<(), tree::MethodErr>; + fn multiple_tones(&self, tones: &str) -> Result<(), tree::MethodErr>; + fn currently_sending_tones(&self) -> Result; + fn initial_tones(&self) -> Result; + fn deferred_tones(&self) -> Result; +} + +pub fn channel_interface_dtmf_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + D::Signal: Default, + T: ChannelInterfaceDTMF, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface("org.freedesktop.Telepathy.Channel.Interface.DTMF", data); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let stream_id: u32 = i.read()?; + let event: u8 = i.read()?; + let d = fclone(minfo); + d.start_tone(stream_id, event)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("StartTone", Default::default(), h); + let m = m.in_arg(("Stream_ID", "u")); + let m = m.in_arg(("Event", "y")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let stream_id: u32 = i.read()?; + let d = fclone(minfo); + d.stop_tone(stream_id)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("StopTone", Default::default(), h); + let m = m.in_arg(("Stream_ID", "u")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let tones: &str = i.read()?; + let d = fclone(minfo); + d.multiple_tones(tones)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("MultipleTones", Default::default(), h); + let m = m.in_arg(("Tones", "s")); + let i = i.add_m(m); + + let p = factory.property::("CurrentlySendingTones", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.currently_sending_tones()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::<&str, _>("InitialTones", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.initial_tones()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::<&str, _>("DeferredTones", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.deferred_tones()?); + Ok(()) + }); + let i = i.add_p(p); + let s = factory.signal("TonesDeferred", Default::default()); + let s = s.arg(("Tones", "s")); + let i = i.add_s(s); + let s = factory.signal("SendingTones", Default::default()); + let s = s.arg(("Tones", "s")); + let i = i.add_s(s); + let s = factory.signal("StoppedTones", Default::default()); + let s = s.arg(("Cancelled", "b")); + let i = i.add_s(s); + i +} + +#[derive(Debug)] +pub struct ChannelInterfaceDTMFTonesDeferred { + pub tones: String, +} + +impl arg::AppendAll for ChannelInterfaceDTMFTonesDeferred { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.tones, i); + } +} + +impl arg::ReadAll for ChannelInterfaceDTMFTonesDeferred { + fn read(i: &mut arg::Iter) -> Result { + Ok(ChannelInterfaceDTMFTonesDeferred { tones: i.read()? }) + } +} + +impl dbus::message::SignalArgs for ChannelInterfaceDTMFTonesDeferred { + const NAME: &'static str = "TonesDeferred"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Interface.DTMF"; +} + +#[derive(Debug)] +pub struct ChannelInterfaceDTMFSendingTones { + pub tones: String, +} + +impl arg::AppendAll for ChannelInterfaceDTMFSendingTones { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.tones, i); + } +} + +impl arg::ReadAll for ChannelInterfaceDTMFSendingTones { + fn read(i: &mut arg::Iter) -> Result { + Ok(ChannelInterfaceDTMFSendingTones { tones: i.read()? }) + } +} + +impl dbus::message::SignalArgs for ChannelInterfaceDTMFSendingTones { + const NAME: &'static str = "SendingTones"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Interface.DTMF"; +} + +#[derive(Debug)] +pub struct ChannelInterfaceDTMFStoppedTones { + pub cancelled: bool, +} + +impl arg::AppendAll for ChannelInterfaceDTMFStoppedTones { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.cancelled, i); + } +} + +impl arg::ReadAll for ChannelInterfaceDTMFStoppedTones { + fn read(i: &mut arg::Iter) -> Result { + Ok(ChannelInterfaceDTMFStoppedTones { + cancelled: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for ChannelInterfaceDTMFStoppedTones { + const NAME: &'static str = "StoppedTones"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Interface.DTMF"; +} diff --git a/src/telepathy/channel_interface_file_transfer_metadata.rs b/src/telepathy/channel_interface_file_transfer_metadata.rs new file mode 100644 index 0000000..d862455 --- /dev/null +++ b/src/telepathy/channel_interface_file_transfer_metadata.rs @@ -0,0 +1,73 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_File_Transfer_Metadata.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_interface_file_transfer_metadata.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ChannelInterfaceFileTransferMetadata { + fn service_name(&self) -> Result; + fn set_service_name(&self, value: String) -> Result<(), tree::MethodErr>; + fn metadata(&self) + -> Result<::std::collections::HashMap>, tree::MethodErr>; + fn set_metadata( + &self, + value: ::std::collections::HashMap>, + ) -> Result<(), tree::MethodErr>; +} + +pub fn channel_interface_file_transfer_metadata_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + T: ChannelInterfaceFileTransferMetadata, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface( + "org.freedesktop.Telepathy.Channel.Interface.FileTransfer.Metadata", + data, + ); + let f = ::std::sync::Arc::new(f); + let p = factory.property::<&str, _>("ServiceName", Default::default()); + let p = p.access(tree::Access::ReadWrite); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.service_name()?); + Ok(()) + }); + let fclone = f.clone(); + let p = p.on_set(move |iter, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + d.set_service_name(iter.read()?)?; + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::<::std::collections::HashMap<&str, Vec<&str>>, _>( + "Metadata", + Default::default(), + ); + let p = p.access(tree::Access::ReadWrite); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.metadata()?); + Ok(()) + }); + let fclone = f.clone(); + let p = p.on_set(move |iter, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + d.set_metadata(iter.read()?)?; + Ok(()) + }); + let i = i.add_p(p); + i +} diff --git a/src/telepathy/channel_interface_group.rs b/src/telepathy/channel_interface_group.rs new file mode 100644 index 0000000..451b10d --- /dev/null +++ b/src/telepathy/channel_interface_group.rs @@ -0,0 +1,532 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_Group.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_interface_group.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ChannelInterfaceGroup { + fn add_members(&self, contacts: Vec, message: &str) -> Result<(), tree::MethodErr>; + fn get_all_members(&self) -> Result<(Vec, Vec, Vec), tree::MethodErr>; + fn get_group_flags(&self) -> Result; + fn get_handle_owners(&self, handles: Vec) -> Result, tree::MethodErr>; + fn get_local_pending_members(&self) -> Result, tree::MethodErr>; + fn get_local_pending_members_with_info( + &self, + ) -> Result, tree::MethodErr>; + fn get_members(&self) -> Result, tree::MethodErr>; + fn get_remote_pending_members(&self) -> Result, tree::MethodErr>; + fn get_self_handle(&self) -> Result; + fn remove_members(&self, contacts: Vec, message: &str) -> Result<(), tree::MethodErr>; + fn remove_members_with_reason( + &self, + contacts: Vec, + message: &str, + reason: u32, + ) -> Result<(), tree::MethodErr>; + fn group_flags(&self) -> Result; + fn handle_owners(&self) -> Result<::std::collections::HashMap, tree::MethodErr>; + fn local_pending_members(&self) -> Result, tree::MethodErr>; + fn members(&self) -> Result, tree::MethodErr>; + fn remote_pending_members(&self) -> Result, tree::MethodErr>; + fn self_handle(&self) -> Result; + fn member_identifiers( + &self, + ) -> Result<::std::collections::HashMap, tree::MethodErr>; +} + +pub fn channel_interface_group_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + D::Signal: Default, + T: ChannelInterfaceGroup, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface("org.freedesktop.Telepathy.Channel.Interface.Group", data); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let contacts: Vec = i.read()?; + let message: &str = i.read()?; + let d = fclone(minfo); + d.add_members(contacts, message)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("AddMembers", Default::default(), h); + let m = m.in_arg(("Contacts", "au")); + let m = m.in_arg(("Message", "s")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let d = fclone(minfo); + let (members, local_pending, remote_pending) = d.get_all_members()?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(members); + let rm = rm.append1(local_pending); + let rm = rm.append1(remote_pending); + Ok(vec![rm]) + }; + let m = factory.method("GetAllMembers", Default::default(), h); + let m = m.out_arg(("Members", "au")); + let m = m.out_arg(("Local_Pending", "au")); + let m = m.out_arg(("Remote_Pending", "au")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let d = fclone(minfo); + let group_flags = d.get_group_flags()?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(group_flags); + Ok(vec![rm]) + }; + let m = factory.method("GetGroupFlags", Default::default(), h); + let m = m.out_arg(("Group_Flags", "u")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let handles: Vec = i.read()?; + let d = fclone(minfo); + let owners = d.get_handle_owners(handles)?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(owners); + Ok(vec![rm]) + }; + let m = factory.method("GetHandleOwners", Default::default(), h); + let m = m.in_arg(("Handles", "au")); + let m = m.out_arg(("Owners", "au")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let d = fclone(minfo); + let handles = d.get_local_pending_members()?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(handles); + Ok(vec![rm]) + }; + let m = factory.method("GetLocalPendingMembers", Default::default(), h); + let m = m.out_arg(("Handles", "au")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let d = fclone(minfo); + let info = d.get_local_pending_members_with_info()?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(info); + Ok(vec![rm]) + }; + let m = factory.method("GetLocalPendingMembersWithInfo", Default::default(), h); + let m = m.out_arg(("Info", "a(uuus)")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let d = fclone(minfo); + let handles = d.get_members()?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(handles); + Ok(vec![rm]) + }; + let m = factory.method("GetMembers", Default::default(), h); + let m = m.out_arg(("Handles", "au")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let d = fclone(minfo); + let handles = d.get_remote_pending_members()?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(handles); + Ok(vec![rm]) + }; + let m = factory.method("GetRemotePendingMembers", Default::default(), h); + let m = m.out_arg(("Handles", "au")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let d = fclone(minfo); + let self_handle = d.get_self_handle()?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(self_handle); + Ok(vec![rm]) + }; + let m = factory.method("GetSelfHandle", Default::default(), h); + let m = m.out_arg(("Self_Handle", "u")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let contacts: Vec = i.read()?; + let message: &str = i.read()?; + let d = fclone(minfo); + d.remove_members(contacts, message)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("RemoveMembers", Default::default(), h); + let m = m.in_arg(("Contacts", "au")); + let m = m.in_arg(("Message", "s")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let contacts: Vec = i.read()?; + let message: &str = i.read()?; + let reason: u32 = i.read()?; + let d = fclone(minfo); + d.remove_members_with_reason(contacts, message, reason)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("RemoveMembersWithReason", Default::default(), h); + let m = m.in_arg(("Contacts", "au")); + let m = m.in_arg(("Message", "s")); + let m = m.in_arg(("Reason", "u")); + let i = i.add_m(m); + + let p = factory.property::("GroupFlags", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.group_flags()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory + .property::<::std::collections::HashMap, _>("HandleOwners", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.handle_owners()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory + .property::, _>("LocalPendingMembers", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.local_pending_members()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::, _>("Members", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.members()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::, _>("RemotePendingMembers", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.remote_pending_members()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("SelfHandle", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.self_handle()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::<::std::collections::HashMap, _>( + "MemberIdentifiers", + Default::default(), + ); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.member_identifiers()?); + Ok(()) + }); + let i = i.add_p(p); + let s = factory.signal("HandleOwnersChanged", Default::default()); + let s = s.arg(("Added", "a{uu}")); + let s = s.arg(("Removed", "au")); + let i = i.add_s(s); + let s = factory.signal("HandleOwnersChangedDetailed", Default::default()); + let s = s.arg(("Added", "a{uu}")); + let s = s.arg(("Removed", "au")); + let s = s.arg(("Identifiers", "a{us}")); + let i = i.add_s(s); + let s = factory.signal("SelfHandleChanged", Default::default()); + let s = s.arg(("Self_Handle", "u")); + let i = i.add_s(s); + let s = factory.signal("SelfContactChanged", Default::default()); + let s = s.arg(("Self_Handle", "u")); + let s = s.arg(("Self_ID", "s")); + let i = i.add_s(s); + let s = factory.signal("GroupFlagsChanged", Default::default()); + let s = s.arg(("Added", "u")); + let s = s.arg(("Removed", "u")); + let i = i.add_s(s); + let s = factory.signal("MembersChanged", Default::default()); + let s = s.arg(("Message", "s")); + let s = s.arg(("Added", "au")); + let s = s.arg(("Removed", "au")); + let s = s.arg(("Local_Pending", "au")); + let s = s.arg(("Remote_Pending", "au")); + let s = s.arg(("Actor", "u")); + let s = s.arg(("Reason", "u")); + let i = i.add_s(s); + let s = factory.signal("MembersChangedDetailed", Default::default()); + let s = s.arg(("Added", "au")); + let s = s.arg(("Removed", "au")); + let s = s.arg(("Local_Pending", "au")); + let s = s.arg(("Remote_Pending", "au")); + let s = s.arg(("Details", "a{sv}")); + let i = i.add_s(s); + i +} + +#[derive(Debug)] +pub struct ChannelInterfaceGroupHandleOwnersChanged { + pub added: ::std::collections::HashMap, + pub removed: Vec, +} + +impl arg::AppendAll for ChannelInterfaceGroupHandleOwnersChanged { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.added, i); + arg::RefArg::append(&self.removed, i); + } +} + +impl arg::ReadAll for ChannelInterfaceGroupHandleOwnersChanged { + fn read(i: &mut arg::Iter) -> Result { + Ok(ChannelInterfaceGroupHandleOwnersChanged { + added: i.read()?, + removed: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for ChannelInterfaceGroupHandleOwnersChanged { + const NAME: &'static str = "HandleOwnersChanged"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Interface.Group"; +} + +#[derive(Debug)] +pub struct ChannelInterfaceGroupHandleOwnersChangedDetailed { + pub added: ::std::collections::HashMap, + pub removed: Vec, + pub identifiers: ::std::collections::HashMap, +} + +impl arg::AppendAll for ChannelInterfaceGroupHandleOwnersChangedDetailed { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.added, i); + arg::RefArg::append(&self.removed, i); + arg::RefArg::append(&self.identifiers, i); + } +} + +impl arg::ReadAll for ChannelInterfaceGroupHandleOwnersChangedDetailed { + fn read(i: &mut arg::Iter) -> Result { + Ok(ChannelInterfaceGroupHandleOwnersChangedDetailed { + added: i.read()?, + removed: i.read()?, + identifiers: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for ChannelInterfaceGroupHandleOwnersChangedDetailed { + const NAME: &'static str = "HandleOwnersChangedDetailed"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Interface.Group"; +} + +#[derive(Debug)] +pub struct ChannelInterfaceGroupSelfHandleChanged { + pub self_handle: u32, +} + +impl arg::AppendAll for ChannelInterfaceGroupSelfHandleChanged { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.self_handle, i); + } +} + +impl arg::ReadAll for ChannelInterfaceGroupSelfHandleChanged { + fn read(i: &mut arg::Iter) -> Result { + Ok(ChannelInterfaceGroupSelfHandleChanged { + self_handle: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for ChannelInterfaceGroupSelfHandleChanged { + const NAME: &'static str = "SelfHandleChanged"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Interface.Group"; +} + +#[derive(Debug)] +pub struct ChannelInterfaceGroupSelfContactChanged { + pub self_handle: u32, + pub self_id: String, +} + +impl arg::AppendAll for ChannelInterfaceGroupSelfContactChanged { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.self_handle, i); + arg::RefArg::append(&self.self_id, i); + } +} + +impl arg::ReadAll for ChannelInterfaceGroupSelfContactChanged { + fn read(i: &mut arg::Iter) -> Result { + Ok(ChannelInterfaceGroupSelfContactChanged { + self_handle: i.read()?, + self_id: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for ChannelInterfaceGroupSelfContactChanged { + const NAME: &'static str = "SelfContactChanged"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Interface.Group"; +} + +#[derive(Debug)] +pub struct ChannelInterfaceGroupGroupFlagsChanged { + pub added: u32, + pub removed: u32, +} + +impl arg::AppendAll for ChannelInterfaceGroupGroupFlagsChanged { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.added, i); + arg::RefArg::append(&self.removed, i); + } +} + +impl arg::ReadAll for ChannelInterfaceGroupGroupFlagsChanged { + fn read(i: &mut arg::Iter) -> Result { + Ok(ChannelInterfaceGroupGroupFlagsChanged { + added: i.read()?, + removed: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for ChannelInterfaceGroupGroupFlagsChanged { + const NAME: &'static str = "GroupFlagsChanged"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Interface.Group"; +} + +#[derive(Debug)] +pub struct ChannelInterfaceGroupMembersChanged { + pub message: String, + pub added: Vec, + pub removed: Vec, + pub local_pending: Vec, + pub remote_pending: Vec, + pub actor: u32, + pub reason: u32, +} + +impl arg::AppendAll for ChannelInterfaceGroupMembersChanged { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.message, i); + arg::RefArg::append(&self.added, i); + arg::RefArg::append(&self.removed, i); + arg::RefArg::append(&self.local_pending, i); + arg::RefArg::append(&self.remote_pending, i); + arg::RefArg::append(&self.actor, i); + arg::RefArg::append(&self.reason, i); + } +} + +impl arg::ReadAll for ChannelInterfaceGroupMembersChanged { + fn read(i: &mut arg::Iter) -> Result { + Ok(ChannelInterfaceGroupMembersChanged { + message: i.read()?, + added: i.read()?, + removed: i.read()?, + local_pending: i.read()?, + remote_pending: i.read()?, + actor: i.read()?, + reason: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for ChannelInterfaceGroupMembersChanged { + const NAME: &'static str = "MembersChanged"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Interface.Group"; +} + +#[derive(Debug)] +pub struct ChannelInterfaceGroupMembersChangedDetailed { + pub added: Vec, + pub removed: Vec, + pub local_pending: Vec, + pub remote_pending: Vec, + pub details: ::std::collections::HashMap>>, +} + +impl arg::AppendAll for ChannelInterfaceGroupMembersChangedDetailed { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.added, i); + arg::RefArg::append(&self.removed, i); + arg::RefArg::append(&self.local_pending, i); + arg::RefArg::append(&self.remote_pending, i); + arg::RefArg::append(&self.details, i); + } +} + +impl arg::ReadAll for ChannelInterfaceGroupMembersChangedDetailed { + fn read(i: &mut arg::Iter) -> Result { + Ok(ChannelInterfaceGroupMembersChangedDetailed { + added: i.read()?, + removed: i.read()?, + local_pending: i.read()?, + remote_pending: i.read()?, + details: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for ChannelInterfaceGroupMembersChangedDetailed { + const NAME: &'static str = "MembersChangedDetailed"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Interface.Group"; +} diff --git a/src/telepathy/channel_interface_hold.rs b/src/telepathy/channel_interface_hold.rs new file mode 100644 index 0000000..d578f3f --- /dev/null +++ b/src/telepathy/channel_interface_hold.rs @@ -0,0 +1,83 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_Hold.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_interface_hold.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ChannelInterfaceHold { + fn get_hold_state(&self) -> Result<(u32, u32), tree::MethodErr>; + fn request_hold(&self, hold: bool) -> Result<(), tree::MethodErr>; +} + +pub fn channel_interface_hold_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Signal: Default, + T: ChannelInterfaceHold, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface("org.freedesktop.Telepathy.Channel.Interface.Hold", data); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let d = fclone(minfo); + let (hold_state, reason) = d.get_hold_state()?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(hold_state); + let rm = rm.append1(reason); + Ok(vec![rm]) + }; + let m = factory.method("GetHoldState", Default::default(), h); + let m = m.out_arg(("HoldState", "u")); + let m = m.out_arg(("Reason", "u")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let hold: bool = i.read()?; + let d = fclone(minfo); + d.request_hold(hold)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("RequestHold", Default::default(), h); + let m = m.in_arg(("Hold", "b")); + let i = i.add_m(m); + let s = factory.signal("HoldStateChanged", Default::default()); + let s = s.arg(("HoldState", "u")); + let s = s.arg(("Reason", "u")); + let i = i.add_s(s); + i +} + +#[derive(Debug)] +pub struct ChannelInterfaceHoldHoldStateChanged { + pub hold_state: u32, + pub reason: u32, +} + +impl arg::AppendAll for ChannelInterfaceHoldHoldStateChanged { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.hold_state, i); + arg::RefArg::append(&self.reason, i); + } +} + +impl arg::ReadAll for ChannelInterfaceHoldHoldStateChanged { + fn read(i: &mut arg::Iter) -> Result { + Ok(ChannelInterfaceHoldHoldStateChanged { + hold_state: i.read()?, + reason: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for ChannelInterfaceHoldHoldStateChanged { + const NAME: &'static str = "HoldStateChanged"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Interface.Hold"; +} diff --git a/src/telepathy/channel_interface_html.rs b/src/telepathy/channel_interface_html.rs new file mode 100644 index 0000000..254f408 --- /dev/null +++ b/src/telepathy/channel_interface_html.rs @@ -0,0 +1,25 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_HTML.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_interface_html.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ChannelInterfaceHTMLDRAFT {} + +pub fn channel_interface_htmldraft_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + T: ChannelInterfaceHTMLDRAFT, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface( + "org.freedesktop.Telepathy.Channel.Interface.HTML.DRAFT", + data, + ); + let f = ::std::sync::Arc::new(f); + i +} diff --git a/src/telepathy/channel_interface_media_signalling.rs b/src/telepathy/channel_interface_media_signalling.rs new file mode 100644 index 0000000..061fe95 --- /dev/null +++ b/src/telepathy/channel_interface_media_signalling.rs @@ -0,0 +1,70 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_Media_Signalling.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_interface_media_signalling.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ChannelInterfaceMediaSignalling { + fn get_session_handlers(&self) -> Result, String)>, tree::MethodErr>; +} + +pub fn channel_interface_media_signalling_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Signal: Default, + T: ChannelInterfaceMediaSignalling, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface( + "org.freedesktop.Telepathy.Channel.Interface.MediaSignalling", + data, + ); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let d = fclone(minfo); + let session_handlers = d.get_session_handlers()?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(session_handlers); + Ok(vec![rm]) + }; + let m = factory.method("GetSessionHandlers", Default::default(), h); + let m = m.out_arg(("Session_Handlers", "a(os)")); + let i = i.add_m(m); + let s = factory.signal("NewSessionHandler", Default::default()); + let s = s.arg(("Session_Handler", "o")); + let s = s.arg(("Session_Type", "s")); + let i = i.add_s(s); + i +} + +#[derive(Debug)] +pub struct ChannelInterfaceMediaSignallingNewSessionHandler { + pub session_handler: dbus::Path<'static>, + pub session_type: String, +} + +impl arg::AppendAll for ChannelInterfaceMediaSignallingNewSessionHandler { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.session_handler, i); + arg::RefArg::append(&self.session_type, i); + } +} + +impl arg::ReadAll for ChannelInterfaceMediaSignallingNewSessionHandler { + fn read(i: &mut arg::Iter) -> Result { + Ok(ChannelInterfaceMediaSignallingNewSessionHandler { + session_handler: i.read()?, + session_type: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for ChannelInterfaceMediaSignallingNewSessionHandler { + const NAME: &'static str = "NewSessionHandler"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Interface.MediaSignalling"; +} diff --git a/src/telepathy/channel_interface_mergeable_conference.rs b/src/telepathy/channel_interface_mergeable_conference.rs new file mode 100644 index 0000000..1cb27c1 --- /dev/null +++ b/src/telepathy/channel_interface_mergeable_conference.rs @@ -0,0 +1,39 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_Mergeable_Conference.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_interface_mergeable_conference.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ChannelInterfaceMergeableConferenceDRAFT { + fn merge(&self, channel: dbus::Path) -> Result<(), tree::MethodErr>; +} + +pub fn channel_interface_mergeable_conference_draft_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + T: ChannelInterfaceMergeableConferenceDRAFT, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface( + "org.freedesktop.Telepathy.Channel.Interface.MergeableConference.DRAFT", + data, + ); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let channel: dbus::Path = i.read()?; + let d = fclone(minfo); + d.merge(channel)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("Merge", Default::default(), h); + let m = m.in_arg(("Channel", "o")); + let i = i.add_m(m); + i +} diff --git a/src/telepathy/channel_interface_messages.rs b/src/telepathy/channel_interface_messages.rs new file mode 100644 index 0000000..b46cc0c --- /dev/null +++ b/src/telepathy/channel_interface_messages.rs @@ -0,0 +1,226 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_Messages.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_interface_messages.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ChannelInterfaceMessages { + fn send_message( + &self, + message: Vec<::std::collections::HashMap<&str, arg::Variant>>>, + flags: u32, + ) -> Result; + fn get_pending_message_content( + &self, + message_id: u32, + parts: Vec, + ) -> Result< + ::std::collections::HashMap>>, + tree::MethodErr, + >; + fn supported_content_types(&self) -> Result, tree::MethodErr>; + fn message_types(&self) -> Result, tree::MethodErr>; + fn message_part_support_flags(&self) -> Result; + fn pending_messages( + &self, + ) -> Result< + Vec>>>>, + tree::MethodErr, + >; + fn delivery_reporting_support(&self) -> Result; +} + +pub fn channel_interface_messages_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + D::Signal: Default, + T: ChannelInterfaceMessages, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface("org.freedesktop.Telepathy.Channel.Interface.Messages", data); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let message: Vec<::std::collections::HashMap<&str, arg::Variant>>> = + i.read()?; + let flags: u32 = i.read()?; + let d = fclone(minfo); + let token = d.send_message(message, flags)?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(token); + Ok(vec![rm]) + }; + let m = factory.method("SendMessage", Default::default(), h); + let m = m.in_arg(("Message", "aa{sv}")); + let m = m.in_arg(("Flags", "u")); + let m = m.out_arg(("Token", "s")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let message_id: u32 = i.read()?; + let parts: Vec = i.read()?; + let d = fclone(minfo); + let content = d.get_pending_message_content(message_id, parts)?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(content); + Ok(vec![rm]) + }; + let m = factory.method("GetPendingMessageContent", Default::default(), h); + let m = m.in_arg(("Message_ID", "u")); + let m = m.in_arg(("Parts", "au")); + let m = m.out_arg(("Content", "a{uv}")); + let i = i.add_m(m); + + let p = factory.property::, _>("SupportedContentTypes", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.supported_content_types()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::, _>("MessageTypes", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.message_types()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("MessagePartSupportFlags", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.message_part_support_flags()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::>>>>, _>("PendingMessages", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.pending_messages()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("DeliveryReportingSupport", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.delivery_reporting_support()?); + Ok(()) + }); + let i = i.add_p(p); + let s = factory.signal("MessageSent", Default::default()); + let s = s.arg(("Content", "aa{sv}")); + let s = s.arg(("Flags", "u")); + let s = s.arg(("Message_Token", "s")); + let i = i.add_s(s); + let s = factory.signal("PendingMessagesRemoved", Default::default()); + let s = s.arg(("Message_IDs", "au")); + let i = i.add_s(s); + let s = factory.signal("MessageReceived", Default::default()); + let s = s.arg(("Message", "aa{sv}")); + let i = i.add_s(s); + i +} + +#[derive(Debug)] +pub struct ChannelInterfaceMessagesMessageSent { + pub content: + Vec<::std::collections::HashMap>>>, + pub flags: u32, + pub message_token: String, +} + +impl arg::AppendAll for ChannelInterfaceMessagesMessageSent { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.content, i); + arg::RefArg::append(&self.flags, i); + arg::RefArg::append(&self.message_token, i); + } +} + +impl arg::ReadAll for ChannelInterfaceMessagesMessageSent { + fn read(i: &mut arg::Iter) -> Result { + Ok(ChannelInterfaceMessagesMessageSent { + content: i.read()?, + flags: i.read()?, + message_token: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for ChannelInterfaceMessagesMessageSent { + const NAME: &'static str = "MessageSent"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Interface.Messages"; +} + +#[derive(Debug)] +pub struct ChannelInterfaceMessagesPendingMessagesRemoved { + pub message_ids: Vec, +} + +impl arg::AppendAll for ChannelInterfaceMessagesPendingMessagesRemoved { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.message_ids, i); + } +} + +impl arg::ReadAll for ChannelInterfaceMessagesPendingMessagesRemoved { + fn read(i: &mut arg::Iter) -> Result { + Ok(ChannelInterfaceMessagesPendingMessagesRemoved { + message_ids: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for ChannelInterfaceMessagesPendingMessagesRemoved { + const NAME: &'static str = "PendingMessagesRemoved"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Interface.Messages"; +} + +#[derive(Debug)] +pub struct ChannelInterfaceMessagesMessageReceived { + pub message: + Vec<::std::collections::HashMap>>>, +} + +impl arg::AppendAll for ChannelInterfaceMessagesMessageReceived { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.message, i); + } +} + +impl arg::ReadAll for ChannelInterfaceMessagesMessageReceived { + fn read(i: &mut arg::Iter) -> Result { + Ok(ChannelInterfaceMessagesMessageReceived { message: i.read()? }) + } +} + +impl dbus::message::SignalArgs for ChannelInterfaceMessagesMessageReceived { + const NAME: &'static str = "MessageReceived"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Interface.Messages"; +} diff --git a/src/telepathy/channel_interface_password.rs b/src/telepathy/channel_interface_password.rs new file mode 100644 index 0000000..8061657 --- /dev/null +++ b/src/telepathy/channel_interface_password.rs @@ -0,0 +1,83 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_Password.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_interface_password.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ChannelInterfacePassword { + fn get_password_flags(&self) -> Result; + fn provide_password(&self, password: &str) -> Result; +} + +pub fn channel_interface_password_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Signal: Default, + T: ChannelInterfacePassword, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface("org.freedesktop.Telepathy.Channel.Interface.Password", data); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let d = fclone(minfo); + let password_flags = d.get_password_flags()?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(password_flags); + Ok(vec![rm]) + }; + let m = factory.method("GetPasswordFlags", Default::default(), h); + let m = m.out_arg(("Password_Flags", "u")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let password: &str = i.read()?; + let d = fclone(minfo); + let correct = d.provide_password(password)?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(correct); + Ok(vec![rm]) + }; + let m = factory.method("ProvidePassword", Default::default(), h); + let m = m.in_arg(("Password", "s")); + let m = m.out_arg(("Correct", "b")); + let i = i.add_m(m); + let s = factory.signal("PasswordFlagsChanged", Default::default()); + let s = s.arg(("Added", "u")); + let s = s.arg(("Removed", "u")); + let i = i.add_s(s); + i +} + +#[derive(Debug)] +pub struct ChannelInterfacePasswordPasswordFlagsChanged { + pub added: u32, + pub removed: u32, +} + +impl arg::AppendAll for ChannelInterfacePasswordPasswordFlagsChanged { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.added, i); + arg::RefArg::append(&self.removed, i); + } +} + +impl arg::ReadAll for ChannelInterfacePasswordPasswordFlagsChanged { + fn read(i: &mut arg::Iter) -> Result { + Ok(ChannelInterfacePasswordPasswordFlagsChanged { + added: i.read()?, + removed: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for ChannelInterfacePasswordPasswordFlagsChanged { + const NAME: &'static str = "PasswordFlagsChanged"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Interface.Password"; +} diff --git a/src/telepathy/channel_interface_picture.rs b/src/telepathy/channel_interface_picture.rs new file mode 100644 index 0000000..c323051 --- /dev/null +++ b/src/telepathy/channel_interface_picture.rs @@ -0,0 +1,195 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_Picture.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_interface_picture.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ChannelInterfacePicture1 { + fn set_picture(&self, picture: Vec, mimetype: &str) -> Result<(), tree::MethodErr>; + fn picture(&self) -> Result<(Vec, String), tree::MethodErr>; + fn actor(&self) -> Result; + fn actor_handle(&self) -> Result; + fn timestamp(&self) -> Result; + fn can_set(&self) -> Result; + fn supported_mimetypes(&self) -> Result, tree::MethodErr>; + fn minimum_height(&self) -> Result; + fn minimum_width(&self) -> Result; + fn recommended_height(&self) -> Result; + fn recommended_width(&self) -> Result; + fn maximum_height(&self) -> Result; + fn maximum_width(&self) -> Result; + fn maximum_bytes(&self) -> Result; +} + +pub fn channel_interface_picture1_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + T: ChannelInterfacePicture1, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface("org.freedesktop.Telepathy.Channel.Interface.Picture1", data); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let picture: Vec = i.read()?; + let mimetype: &str = i.read()?; + let d = fclone(minfo); + d.set_picture(picture, mimetype)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("SetPicture", Default::default(), h); + let m = m.in_arg(("Picture", "ay")); + let m = m.in_arg(("MIME_Type", "s")); + let i = i.add_m(m); + + let p = factory.property::<(Vec, &str), _>("Picture", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.picture()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::<&str, _>("Actor", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.actor()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("ActorHandle", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.actor_handle()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("Timestamp", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.timestamp()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("CanSet", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.can_set()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::, _>("SupportedMIMETypes", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.supported_mimetypes()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("MinimumHeight", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.minimum_height()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("MinimumWidth", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.minimum_width()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("RecommendedHeight", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.recommended_height()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("RecommendedWidth", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.recommended_width()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("MaximumHeight", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.maximum_height()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("MaximumWidth", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.maximum_width()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("MaximumBytes", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.maximum_bytes()?); + Ok(()) + }); + let i = i.add_p(p); + i +} diff --git a/src/telepathy/channel_interface_room.rs b/src/telepathy/channel_interface_room.rs new file mode 100644 index 0000000..70d0d9f --- /dev/null +++ b/src/telepathy/channel_interface_room.rs @@ -0,0 +1,83 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_Room.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_interface_room.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ChannelInterfaceRoom2 { + fn room_name(&self) -> Result; + fn server(&self) -> Result; + fn creator(&self) -> Result; + fn creator_handle(&self) -> Result; + fn creation_timestamp(&self) -> Result; +} + +pub fn channel_interface_room2_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + T: ChannelInterfaceRoom2, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface("org.freedesktop.Telepathy.Channel.Interface.Room2", data); + let f = ::std::sync::Arc::new(f); + let p = factory.property::<&str, _>("RoomName", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.room_name()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::<&str, _>("Server", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.server()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::<&str, _>("Creator", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.creator()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("CreatorHandle", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.creator_handle()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("CreationTimestamp", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.creation_timestamp()?); + Ok(()) + }); + let i = i.add_p(p); + i +} diff --git a/src/telepathy/channel_interface_room_config.rs b/src/telepathy/channel_interface_room_config.rs new file mode 100644 index 0000000..617b35a --- /dev/null +++ b/src/telepathy/channel_interface_room_config.rs @@ -0,0 +1,212 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_Room_Config.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_interface_room_config.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ChannelInterfaceRoomConfig1 { + fn update_configuration( + &self, + properties: ::std::collections::HashMap<&str, arg::Variant>>, + ) -> Result<(), tree::MethodErr>; + fn anonymous(&self) -> Result; + fn invite_only(&self) -> Result; + fn limit(&self) -> Result; + fn moderated(&self) -> Result; + fn title(&self) -> Result; + fn description(&self) -> Result; + fn persistent(&self) -> Result; + fn private(&self) -> Result; + fn password_protected(&self) -> Result; + fn password(&self) -> Result; + fn password_hint(&self) -> Result; + fn can_update_configuration(&self) -> Result; + fn mutable_properties(&self) -> Result, tree::MethodErr>; + fn configuration_retrieved(&self) -> Result; +} + +pub fn channel_interface_room_config1_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + T: ChannelInterfaceRoomConfig1, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface( + "org.freedesktop.Telepathy.Channel.Interface.RoomConfig1", + data, + ); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let properties: ::std::collections::HashMap<&str, arg::Variant>> = + i.read()?; + let d = fclone(minfo); + d.update_configuration(properties)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("UpdateConfiguration", Default::default(), h); + let m = m.in_arg(("Properties", "a{sv}")); + let i = i.add_m(m); + + let p = factory.property::("Anonymous", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.anonymous()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("InviteOnly", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.invite_only()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("Limit", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.limit()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("Moderated", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.moderated()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::<&str, _>("Title", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.title()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::<&str, _>("Description", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.description()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("Persistent", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.persistent()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("Private", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.private()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("PasswordProtected", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.password_protected()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::<&str, _>("Password", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.password()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::<&str, _>("PasswordHint", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.password_hint()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("CanUpdateConfiguration", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.can_update_configuration()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::, _>("MutableProperties", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.mutable_properties()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("ConfigurationRetrieved", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.configuration_retrieved()?); + Ok(()) + }); + let i = i.add_p(p); + i +} diff --git a/src/telepathy/channel_interface_sasl_authentication.rs b/src/telepathy/channel_interface_sasl_authentication.rs new file mode 100644 index 0000000..bf820e0 --- /dev/null +++ b/src/telepathy/channel_interface_sasl_authentication.rs @@ -0,0 +1,295 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_SASL_Authentication.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_interface_sasl_authentication.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ChannelInterfaceSASLAuthentication { + fn start_mechanism(&self, mechanism: &str) -> Result<(), tree::MethodErr>; + fn start_mechanism_with_data( + &self, + mechanism: &str, + initial_data: Vec, + ) -> Result<(), tree::MethodErr>; + fn respond(&self, response_data: Vec) -> Result<(), tree::MethodErr>; + fn accept_sasl(&self) -> Result<(), tree::MethodErr>; + fn abort_sasl(&self, reason: u32, debug_message: &str) -> Result<(), tree::MethodErr>; + fn available_mechanisms(&self) -> Result, tree::MethodErr>; + fn has_initial_data(&self) -> Result; + fn can_try_again(&self) -> Result; + fn saslstatus(&self) -> Result; + fn saslerror(&self) -> Result; + fn saslerror_details( + &self, + ) -> Result< + ::std::collections::HashMap>>, + tree::MethodErr, + >; + fn authorization_identity(&self) -> Result; + fn default_username(&self) -> Result; + fn default_realm(&self) -> Result; + fn may_save_response(&self) -> Result; +} + +pub fn channel_interface_saslauthentication_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + D::Signal: Default, + T: ChannelInterfaceSASLAuthentication, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface( + "org.freedesktop.Telepathy.Channel.Interface.SASLAuthentication", + data, + ); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let mechanism: &str = i.read()?; + let d = fclone(minfo); + d.start_mechanism(mechanism)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("StartMechanism", Default::default(), h); + let m = m.in_arg(("Mechanism", "s")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let mechanism: &str = i.read()?; + let initial_data: Vec = i.read()?; + let d = fclone(minfo); + d.start_mechanism_with_data(mechanism, initial_data)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("StartMechanismWithData", Default::default(), h); + let m = m.in_arg(("Mechanism", "s")); + let m = m.in_arg(("Initial_Data", "ay")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let response_data: Vec = i.read()?; + let d = fclone(minfo); + d.respond(response_data)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("Respond", Default::default(), h); + let m = m.in_arg(("Response_Data", "ay")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let d = fclone(minfo); + d.accept_sasl()?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("AcceptSASL", Default::default(), h); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let reason: u32 = i.read()?; + let debug_message: &str = i.read()?; + let d = fclone(minfo); + d.abort_sasl(reason, debug_message)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("AbortSASL", Default::default(), h); + let m = m.in_arg(("Reason", "u")); + let m = m.in_arg(("Debug_Message", "s")); + let i = i.add_m(m); + + let p = factory.property::, _>("AvailableMechanisms", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.available_mechanisms()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("HasInitialData", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.has_initial_data()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("CanTryAgain", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.can_try_again()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("SASLStatus", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.saslstatus()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::<&str, _>("SASLError", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.saslerror()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory + .property::<::std::collections::HashMap<&str, arg::Variant>>, _>( + "SASLErrorDetails", + Default::default(), + ); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.saslerror_details()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::<&str, _>("AuthorizationIdentity", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.authorization_identity()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::<&str, _>("DefaultUsername", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.default_username()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::<&str, _>("DefaultRealm", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.default_realm()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("MaySaveResponse", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.may_save_response()?); + Ok(()) + }); + let i = i.add_p(p); + let s = factory.signal("SASLStatusChanged", Default::default()); + let s = s.arg(("Status", "u")); + let s = s.arg(("Reason", "s")); + let s = s.arg(("Details", "a{sv}")); + let i = i.add_s(s); + let s = factory.signal("NewChallenge", Default::default()); + let s = s.arg(("Challenge_Data", "ay")); + let i = i.add_s(s); + i +} + +#[derive(Debug)] +pub struct ChannelInterfaceSASLAuthenticationSASLStatusChanged { + pub status: u32, + pub reason: String, + pub details: ::std::collections::HashMap>>, +} + +impl arg::AppendAll for ChannelInterfaceSASLAuthenticationSASLStatusChanged { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.status, i); + arg::RefArg::append(&self.reason, i); + arg::RefArg::append(&self.details, i); + } +} + +impl arg::ReadAll for ChannelInterfaceSASLAuthenticationSASLStatusChanged { + fn read(i: &mut arg::Iter) -> Result { + Ok(ChannelInterfaceSASLAuthenticationSASLStatusChanged { + status: i.read()?, + reason: i.read()?, + details: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for ChannelInterfaceSASLAuthenticationSASLStatusChanged { + const NAME: &'static str = "SASLStatusChanged"; + const INTERFACE: &'static str = + "org.freedesktop.Telepathy.Channel.Interface.SASLAuthentication"; +} + +#[derive(Debug)] +pub struct ChannelInterfaceSASLAuthenticationNewChallenge { + pub challenge_data: Vec, +} + +impl arg::AppendAll for ChannelInterfaceSASLAuthenticationNewChallenge { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.challenge_data, i); + } +} + +impl arg::ReadAll for ChannelInterfaceSASLAuthenticationNewChallenge { + fn read(i: &mut arg::Iter) -> Result { + Ok(ChannelInterfaceSASLAuthenticationNewChallenge { + challenge_data: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for ChannelInterfaceSASLAuthenticationNewChallenge { + const NAME: &'static str = "NewChallenge"; + const INTERFACE: &'static str = + "org.freedesktop.Telepathy.Channel.Interface.SASLAuthentication"; +} diff --git a/src/telepathy/channel_interface_securable.rs b/src/telepathy/channel_interface_securable.rs new file mode 100644 index 0000000..bc4e2d5 --- /dev/null +++ b/src/telepathy/channel_interface_securable.rs @@ -0,0 +1,50 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_Securable.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_interface_securable.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ChannelInterfaceSecurable { + fn encrypted(&self) -> Result; + fn verified(&self) -> Result; +} + +pub fn channel_interface_securable_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + T: ChannelInterfaceSecurable, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface( + "org.freedesktop.Telepathy.Channel.Interface.Securable", + data, + ); + let f = ::std::sync::Arc::new(f); + let p = factory.property::("Encrypted", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.encrypted()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("Verified", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.verified()?); + Ok(()) + }); + let i = i.add_p(p); + i +} diff --git a/src/telepathy/channel_interface_service_point.rs b/src/telepathy/channel_interface_service_point.rs new file mode 100644 index 0000000..90a1fa6 --- /dev/null +++ b/src/telepathy/channel_interface_service_point.rs @@ -0,0 +1,78 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_Service_Point.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_interface_service_point.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ChannelInterfaceServicePoint { + fn initial_service_point(&self) -> Result<(u32, String), tree::MethodErr>; + fn current_service_point(&self) -> Result<(u32, String), tree::MethodErr>; +} + +pub fn channel_interface_service_point_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + D::Signal: Default, + T: ChannelInterfaceServicePoint, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface( + "org.freedesktop.Telepathy.Channel.Interface.ServicePoint", + data, + ); + let f = ::std::sync::Arc::new(f); + let p = factory.property::<(u32, &str), _>("InitialServicePoint", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.initial_service_point()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::<(u32, &str), _>("CurrentServicePoint", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.current_service_point()?); + Ok(()) + }); + let i = i.add_p(p); + let s = factory.signal("ServicePointChanged", Default::default()); + let s = s.arg(("Service_Point", "(us)")); + let i = i.add_s(s); + i +} + +#[derive(Debug)] +pub struct ChannelInterfaceServicePointServicePointChanged { + pub service_point: (u32, String), +} + +impl arg::AppendAll for ChannelInterfaceServicePointServicePointChanged { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.service_point, i); + } +} + +impl arg::ReadAll for ChannelInterfaceServicePointServicePointChanged { + fn read(i: &mut arg::Iter) -> Result { + Ok(ChannelInterfaceServicePointServicePointChanged { + service_point: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for ChannelInterfaceServicePointServicePointChanged { + const NAME: &'static str = "ServicePointChanged"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Interface.ServicePoint"; +} diff --git a/src/telepathy/channel_interface_sms.rs b/src/telepathy/channel_interface_sms.rs new file mode 100644 index 0000000..76021ee --- /dev/null +++ b/src/telepathy/channel_interface_sms.rs @@ -0,0 +1,99 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_SMS.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_interface_sms.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ChannelInterfaceSMS { + fn get_smslength( + &self, + message: Vec<::std::collections::HashMap<&str, arg::Variant>>>, + ) -> Result<(u32, i32, i32), tree::MethodErr>; + fn flash(&self) -> Result; + fn smschannel(&self) -> Result; +} + +pub fn channel_interface_sms_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + D::Signal: Default, + T: ChannelInterfaceSMS, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface("org.freedesktop.Telepathy.Channel.Interface.SMS", data); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let message: Vec<::std::collections::HashMap<&str, arg::Variant>>> = + i.read()?; + let d = fclone(minfo); + let (chunks_required, remaining_characters, estimated_cost) = d.get_smslength(message)?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(chunks_required); + let rm = rm.append1(remaining_characters); + let rm = rm.append1(estimated_cost); + Ok(vec![rm]) + }; + let m = factory.method("GetSMSLength", Default::default(), h); + let m = m.in_arg(("Message", "aa{sv}")); + let m = m.out_arg(("Chunks_Required", "u")); + let m = m.out_arg(("Remaining_Characters", "i")); + let m = m.out_arg(("Estimated_Cost", "i")); + let i = i.add_m(m); + + let p = factory.property::("Flash", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.flash()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("SMSChannel", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.smschannel()?); + Ok(()) + }); + let i = i.add_p(p); + let s = factory.signal("SMSChannelChanged", Default::default()); + let s = s.arg(("SMSChannel", "b")); + let i = i.add_s(s); + i +} + +#[derive(Debug)] +pub struct ChannelInterfaceSMSSMSChannelChanged { + pub smschannel: bool, +} + +impl arg::AppendAll for ChannelInterfaceSMSSMSChannelChanged { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.smschannel, i); + } +} + +impl arg::ReadAll for ChannelInterfaceSMSSMSChannelChanged { + fn read(i: &mut arg::Iter) -> Result { + Ok(ChannelInterfaceSMSSMSChannelChanged { + smschannel: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for ChannelInterfaceSMSSMSChannelChanged { + const NAME: &'static str = "SMSChannelChanged"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Interface.SMS"; +} diff --git a/src/telepathy/channel_interface_splittable.rs b/src/telepathy/channel_interface_splittable.rs new file mode 100644 index 0000000..d7308ec --- /dev/null +++ b/src/telepathy/channel_interface_splittable.rs @@ -0,0 +1,36 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_Splittable.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_interface_splittable.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ChannelInterfaceSplittableDRAFT { + fn split(&self) -> Result<(), tree::MethodErr>; +} + +pub fn channel_interface_splittable_draft_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + T: ChannelInterfaceSplittableDRAFT, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface( + "org.freedesktop.Telepathy.Channel.Interface.Splittable.DRAFT", + data, + ); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let d = fclone(minfo); + d.split()?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("Split", Default::default(), h); + let i = i.add_m(m); + i +} diff --git a/src/telepathy/channel_interface_subject.rs b/src/telepathy/channel_interface_subject.rs new file mode 100644 index 0000000..9914efa --- /dev/null +++ b/src/telepathy/channel_interface_subject.rs @@ -0,0 +1,97 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_Subject.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_interface_subject.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ChannelInterfaceSubject2 { + fn set_subject(&self, subject: &str) -> Result<(), tree::MethodErr>; + fn subject(&self) -> Result; + fn actor(&self) -> Result; + fn actor_handle(&self) -> Result; + fn timestamp(&self) -> Result; + fn can_set(&self) -> Result; +} + +pub fn channel_interface_subject2_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + T: ChannelInterfaceSubject2, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface("org.freedesktop.Telepathy.Channel.Interface.Subject2", data); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let subject: &str = i.read()?; + let d = fclone(minfo); + d.set_subject(subject)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("SetSubject", Default::default(), h); + let m = m.in_arg(("Subject", "s")); + let i = i.add_m(m); + + let p = factory.property::<&str, _>("Subject", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.subject()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::<&str, _>("Actor", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.actor()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("ActorHandle", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.actor_handle()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("Timestamp", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.timestamp()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("CanSet", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.can_set()?); + Ok(()) + }); + let i = i.add_p(p); + i +} diff --git a/src/telepathy/channel_interface_transfer.rs b/src/telepathy/channel_interface_transfer.rs new file mode 100644 index 0000000..210f735 --- /dev/null +++ b/src/telepathy/channel_interface_transfer.rs @@ -0,0 +1,38 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_Transfer.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_interface_transfer.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ChannelInterfaceTransfer { + fn transfer(&self, member: u32, destination: u32) -> Result<(), tree::MethodErr>; +} + +pub fn channel_interface_transfer_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + T: ChannelInterfaceTransfer, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface("org.freedesktop.Telepathy.Channel.Interface.Transfer", data); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let member: u32 = i.read()?; + let destination: u32 = i.read()?; + let d = fclone(minfo); + d.transfer(member, destination)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("Transfer", Default::default(), h); + let m = m.in_arg(("Member", "u")); + let m = m.in_arg(("Destination", "u")); + let i = i.add_m(m); + i +} diff --git a/src/telepathy/channel_interface_tube.rs b/src/telepathy/channel_interface_tube.rs new file mode 100644 index 0000000..f85bd8f --- /dev/null +++ b/src/telepathy/channel_interface_tube.rs @@ -0,0 +1,82 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Interface_Tube.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_interface_tube.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ChannelInterfaceTube { + fn parameters( + &self, + ) -> Result< + ::std::collections::HashMap>>, + tree::MethodErr, + >; + fn state(&self) -> Result; +} + +pub fn channel_interface_tube_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + D::Signal: Default, + T: ChannelInterfaceTube, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface("org.freedesktop.Telepathy.Channel.Interface.Tube", data); + let f = ::std::sync::Arc::new(f); + let p = factory + .property::<::std::collections::HashMap<&str, arg::Variant>>, _>( + "Parameters", + Default::default(), + ); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.parameters()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("State", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.state()?); + Ok(()) + }); + let i = i.add_p(p); + let s = factory.signal("TubeChannelStateChanged", Default::default()); + let s = s.arg(("State", "u")); + let i = i.add_s(s); + i +} + +#[derive(Debug)] +pub struct ChannelInterfaceTubeTubeChannelStateChanged { + pub state: u32, +} + +impl arg::AppendAll for ChannelInterfaceTubeTubeChannelStateChanged { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.state, i); + } +} + +impl arg::ReadAll for ChannelInterfaceTubeTubeChannelStateChanged { + fn read(i: &mut arg::Iter) -> Result { + Ok(ChannelInterfaceTubeTubeChannelStateChanged { state: i.read()? }) + } +} + +impl dbus::message::SignalArgs for ChannelInterfaceTubeTubeChannelStateChanged { + const NAME: &'static str = "TubeChannelStateChanged"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Interface.Tube"; +} diff --git a/src/telepathy/channel_request.rs b/src/telepathy/channel_request.rs new file mode 100644 index 0000000..58be920 --- /dev/null +++ b/src/telepathy/channel_request.rs @@ -0,0 +1,228 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Request.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_request.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ChannelRequest { + fn proceed(&self) -> Result<(), tree::MethodErr>; + fn cancel(&self) -> Result<(), tree::MethodErr>; + fn account(&self) -> Result, tree::MethodErr>; + fn user_action_time(&self) -> Result; + fn preferred_handler(&self) -> Result; + fn requests( + &self, + ) -> Result< + Vec<::std::collections::HashMap>>>, + tree::MethodErr, + >; + fn interfaces(&self) -> Result, tree::MethodErr>; + fn hints( + &self, + ) -> Result< + ::std::collections::HashMap>>, + tree::MethodErr, + >; +} + +pub fn channel_request_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + D::Signal: Default, + T: ChannelRequest, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface("org.freedesktop.Telepathy.ChannelRequest", data); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let d = fclone(minfo); + d.proceed()?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("Proceed", Default::default(), h); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let d = fclone(minfo); + d.cancel()?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("Cancel", Default::default(), h); + let i = i.add_m(m); + + let p = factory.property::("Account", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.account()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("UserActionTime", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.user_action_time()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::<&str, _>("PreferredHandler", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.preferred_handler()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory + .property::>>>, _>( + "Requests", + Default::default(), + ); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.requests()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::, _>("Interfaces", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.interfaces()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory + .property::<::std::collections::HashMap<&str, arg::Variant>>, _>( + "Hints", + Default::default(), + ); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.hints()?); + Ok(()) + }); + let i = i.add_p(p); + let s = factory.signal("Failed", Default::default()); + let s = s.arg(("Error", "s")); + let s = s.arg(("Message", "s")); + let i = i.add_s(s); + let s = factory.signal("Succeeded", Default::default()); + let i = i.add_s(s); + let s = factory.signal("SucceededWithChannel", Default::default()); + let s = s.arg(("Connection", "o")); + let s = s.arg(("Connection_Properties", "a{sv}")); + let s = s.arg(("Channel", "o")); + let s = s.arg(("Channel_Properties", "a{sv}")); + let i = i.add_s(s); + i +} + +#[derive(Debug)] +pub struct ChannelRequestFailed { + pub error: String, + pub message: String, +} + +impl arg::AppendAll for ChannelRequestFailed { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.error, i); + arg::RefArg::append(&self.message, i); + } +} + +impl arg::ReadAll for ChannelRequestFailed { + fn read(i: &mut arg::Iter) -> Result { + Ok(ChannelRequestFailed { + error: i.read()?, + message: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for ChannelRequestFailed { + const NAME: &'static str = "Failed"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.ChannelRequest"; +} + +#[derive(Debug)] +pub struct ChannelRequestSucceeded {} + +impl arg::AppendAll for ChannelRequestSucceeded { + fn append(&self, _: &mut arg::IterAppend) {} +} + +impl arg::ReadAll for ChannelRequestSucceeded { + fn read(_: &mut arg::Iter) -> Result { + Ok(ChannelRequestSucceeded {}) + } +} + +impl dbus::message::SignalArgs for ChannelRequestSucceeded { + const NAME: &'static str = "Succeeded"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.ChannelRequest"; +} + +#[derive(Debug)] +pub struct ChannelRequestSucceededWithChannel { + pub connection: dbus::Path<'static>, + pub connection_properties: + ::std::collections::HashMap>>, + pub channel: dbus::Path<'static>, + pub channel_properties: + ::std::collections::HashMap>>, +} + +impl arg::AppendAll for ChannelRequestSucceededWithChannel { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.connection, i); + arg::RefArg::append(&self.connection_properties, i); + arg::RefArg::append(&self.channel, i); + arg::RefArg::append(&self.channel_properties, i); + } +} + +impl arg::ReadAll for ChannelRequestSucceededWithChannel { + fn read(i: &mut arg::Iter) -> Result { + Ok(ChannelRequestSucceededWithChannel { + connection: i.read()?, + connection_properties: i.read()?, + channel: i.read()?, + channel_properties: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for ChannelRequestSucceededWithChannel { + const NAME: &'static str = "SucceededWithChannel"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.ChannelRequest"; +} diff --git a/src/telepathy/channel_type_call.rs b/src/telepathy/channel_type_call.rs new file mode 100644 index 0000000..0c51a47 --- /dev/null +++ b/src/telepathy/channel_type_call.rs @@ -0,0 +1,423 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Type_Call.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_type_call.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ChannelTypeCall1 { + fn set_ringing(&self) -> Result<(), tree::MethodErr>; + fn set_queued(&self) -> Result<(), tree::MethodErr>; + fn accept(&self) -> Result<(), tree::MethodErr>; + fn hangup( + &self, + reason: u32, + detailed_hangup_reason: &str, + message: &str, + ) -> Result<(), tree::MethodErr>; + fn add_content( + &self, + content_name: &str, + content_type: u32, + initial_direction: u32, + ) -> Result, tree::MethodErr>; + fn contents(&self) -> Result>, tree::MethodErr>; + fn call_state_details( + &self, + ) -> Result< + ::std::collections::HashMap>>, + tree::MethodErr, + >; + fn call_state(&self) -> Result; + fn call_flags(&self) -> Result; + fn call_state_reason(&self) -> Result<(u32, u32, String, String), tree::MethodErr>; + fn hardware_streaming(&self) -> Result; + fn call_members(&self) -> Result<::std::collections::HashMap, tree::MethodErr>; + fn member_identifiers( + &self, + ) -> Result<::std::collections::HashMap, tree::MethodErr>; + fn initial_transport(&self) -> Result; + fn initial_audio(&self) -> Result; + fn initial_video(&self) -> Result; + fn initial_audio_name(&self) -> Result; + fn initial_video_name(&self) -> Result; + fn mutable_contents(&self) -> Result; +} + +pub fn channel_type_call1_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + D::Signal: Default, + T: ChannelTypeCall1, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface("org.freedesktop.Telepathy.Channel.Type.Call1", data); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let d = fclone(minfo); + d.set_ringing()?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("SetRinging", Default::default(), h); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let d = fclone(minfo); + d.set_queued()?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("SetQueued", Default::default(), h); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let d = fclone(minfo); + d.accept()?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("Accept", Default::default(), h); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let reason: u32 = i.read()?; + let detailed_hangup_reason: &str = i.read()?; + let message: &str = i.read()?; + let d = fclone(minfo); + d.hangup(reason, detailed_hangup_reason, message)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("Hangup", Default::default(), h); + let m = m.in_arg(("Reason", "u")); + let m = m.in_arg(("Detailed_Hangup_Reason", "s")); + let m = m.in_arg(("Message", "s")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let content_name: &str = i.read()?; + let content_type: u32 = i.read()?; + let initial_direction: u32 = i.read()?; + let d = fclone(minfo); + let content = d.add_content(content_name, content_type, initial_direction)?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(content); + Ok(vec![rm]) + }; + let m = factory.method("AddContent", Default::default(), h); + let m = m.in_arg(("Content_Name", "s")); + let m = m.in_arg(("Content_Type", "u")); + let m = m.in_arg(("InitialDirection", "u")); + let m = m.out_arg(("Content", "o")); + let i = i.add_m(m); + + let p = factory.property::, _>("Contents", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.contents()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory + .property::<::std::collections::HashMap<&str, arg::Variant>>, _>( + "CallStateDetails", + Default::default(), + ); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.call_state_details()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("CallState", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.call_state()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("CallFlags", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.call_flags()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::<(u32, u32, &str, &str), _>("CallStateReason", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.call_state_reason()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("HardwareStreaming", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.hardware_streaming()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory + .property::<::std::collections::HashMap, _>("CallMembers", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.call_members()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::<::std::collections::HashMap, _>( + "MemberIdentifiers", + Default::default(), + ); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.member_identifiers()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("InitialTransport", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.initial_transport()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("InitialAudio", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.initial_audio()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("InitialVideo", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.initial_video()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::<&str, _>("InitialAudioName", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.initial_audio_name()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::<&str, _>("InitialVideoName", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.initial_video_name()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("MutableContents", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.mutable_contents()?); + Ok(()) + }); + let i = i.add_p(p); + let s = factory.signal("ContentAdded", Default::default()); + let s = s.arg(("Content", "o")); + let i = i.add_s(s); + let s = factory.signal("ContentRemoved", Default::default()); + let s = s.arg(("Content", "o")); + let s = s.arg(("Reason", "(uuss)")); + let i = i.add_s(s); + let s = factory.signal("CallStateChanged", Default::default()); + let s = s.arg(("Call_State", "u")); + let s = s.arg(("Call_Flags", "u")); + let s = s.arg(("Call_State_Reason", "(uuss)")); + let s = s.arg(("Call_State_Details", "a{sv}")); + let i = i.add_s(s); + let s = factory.signal("CallMembersChanged", Default::default()); + let s = s.arg(("Flags_Changed", "a{uu}")); + let s = s.arg(("Identifiers", "a{us}")); + let s = s.arg(("Removed", "au")); + let s = s.arg(("Reason", "(uuss)")); + let i = i.add_s(s); + i +} + +#[derive(Debug)] +pub struct ChannelTypeCall1ContentAdded { + pub content: dbus::Path<'static>, +} + +impl arg::AppendAll for ChannelTypeCall1ContentAdded { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.content, i); + } +} + +impl arg::ReadAll for ChannelTypeCall1ContentAdded { + fn read(i: &mut arg::Iter) -> Result { + Ok(ChannelTypeCall1ContentAdded { content: i.read()? }) + } +} + +impl dbus::message::SignalArgs for ChannelTypeCall1ContentAdded { + const NAME: &'static str = "ContentAdded"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Type.Call1"; +} + +#[derive(Debug)] +pub struct ChannelTypeCall1ContentRemoved { + pub content: dbus::Path<'static>, + pub reason: (u32, u32, String, String), +} + +impl arg::AppendAll for ChannelTypeCall1ContentRemoved { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.content, i); + arg::RefArg::append(&self.reason, i); + } +} + +impl arg::ReadAll for ChannelTypeCall1ContentRemoved { + fn read(i: &mut arg::Iter) -> Result { + Ok(ChannelTypeCall1ContentRemoved { + content: i.read()?, + reason: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for ChannelTypeCall1ContentRemoved { + const NAME: &'static str = "ContentRemoved"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Type.Call1"; +} + +#[derive(Debug)] +pub struct ChannelTypeCall1CallStateChanged { + pub call_state: u32, + pub call_flags: u32, + pub call_state_reason: (u32, u32, String, String), + pub call_state_details: + ::std::collections::HashMap>>, +} + +impl arg::AppendAll for ChannelTypeCall1CallStateChanged { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.call_state, i); + arg::RefArg::append(&self.call_flags, i); + arg::RefArg::append(&self.call_state_reason, i); + arg::RefArg::append(&self.call_state_details, i); + } +} + +impl arg::ReadAll for ChannelTypeCall1CallStateChanged { + fn read(i: &mut arg::Iter) -> Result { + Ok(ChannelTypeCall1CallStateChanged { + call_state: i.read()?, + call_flags: i.read()?, + call_state_reason: i.read()?, + call_state_details: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for ChannelTypeCall1CallStateChanged { + const NAME: &'static str = "CallStateChanged"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Type.Call1"; +} + +#[derive(Debug)] +pub struct ChannelTypeCall1CallMembersChanged { + pub flags_changed: ::std::collections::HashMap, + pub identifiers: ::std::collections::HashMap, + pub removed: Vec, + pub reason: (u32, u32, String, String), +} + +impl arg::AppendAll for ChannelTypeCall1CallMembersChanged { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.flags_changed, i); + arg::RefArg::append(&self.identifiers, i); + arg::RefArg::append(&self.removed, i); + arg::RefArg::append(&self.reason, i); + } +} + +impl arg::ReadAll for ChannelTypeCall1CallMembersChanged { + fn read(i: &mut arg::Iter) -> Result { + Ok(ChannelTypeCall1CallMembersChanged { + flags_changed: i.read()?, + identifiers: i.read()?, + removed: i.read()?, + reason: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for ChannelTypeCall1CallMembersChanged { + const NAME: &'static str = "CallMembersChanged"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Type.Call1"; +} diff --git a/src/telepathy/channel_type_contact_list.rs b/src/telepathy/channel_type_contact_list.rs new file mode 100644 index 0000000..cfa88ad --- /dev/null +++ b/src/telepathy/channel_type_contact_list.rs @@ -0,0 +1,22 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Type_Contact_List.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_type_contact_list.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ChannelTypeContactList {} + +pub fn channel_type_contact_list_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + T: ChannelTypeContactList, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface("org.freedesktop.Telepathy.Channel.Type.ContactList", data); + let f = ::std::sync::Arc::new(f); + i +} diff --git a/src/telepathy/channel_type_contact_search.rs b/src/telepathy/channel_type_contact_search.rs new file mode 100644 index 0000000..ed06439 --- /dev/null +++ b/src/telepathy/channel_type_contact_search.rs @@ -0,0 +1,169 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Type_Contact_Search.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_type_contact_search.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ChannelTypeContactSearch { + fn search(&self, terms: ::std::collections::HashMap<&str, &str>) + -> Result<(), tree::MethodErr>; + fn more(&self) -> Result<(), tree::MethodErr>; + fn stop(&self) -> Result<(), tree::MethodErr>; + fn search_state(&self) -> Result; + fn limit(&self) -> Result; + fn available_search_keys(&self) -> Result, tree::MethodErr>; + fn server(&self) -> Result; +} + +pub fn channel_type_contact_search_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + D::Signal: Default, + T: ChannelTypeContactSearch, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface("org.freedesktop.Telepathy.Channel.Type.ContactSearch", data); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let terms: ::std::collections::HashMap<&str, &str> = i.read()?; + let d = fclone(minfo); + d.search(terms)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("Search", Default::default(), h); + let m = m.in_arg(("Terms", "a{ss}")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let d = fclone(minfo); + d.more()?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("More", Default::default(), h); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let d = fclone(minfo); + d.stop()?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("Stop", Default::default(), h); + let i = i.add_m(m); + + let p = factory.property::("SearchState", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.search_state()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("Limit", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.limit()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::, _>("AvailableSearchKeys", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.available_search_keys()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::<&str, _>("Server", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.server()?); + Ok(()) + }); + let i = i.add_p(p); + let s = factory.signal("SearchStateChanged", Default::default()); + let s = s.arg(("State", "u")); + let s = s.arg(("Error", "s")); + let s = s.arg(("Details", "a{sv}")); + let i = i.add_s(s); + let s = factory.signal("SearchResultReceived", Default::default()); + let s = s.arg(("Result", "a{sa(sasas)}")); + let i = i.add_s(s); + i +} + +#[derive(Debug)] +pub struct ChannelTypeContactSearchSearchStateChanged { + pub state: u32, + pub error: String, + pub details: ::std::collections::HashMap>>, +} + +impl arg::AppendAll for ChannelTypeContactSearchSearchStateChanged { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.state, i); + arg::RefArg::append(&self.error, i); + arg::RefArg::append(&self.details, i); + } +} + +impl arg::ReadAll for ChannelTypeContactSearchSearchStateChanged { + fn read(i: &mut arg::Iter) -> Result { + Ok(ChannelTypeContactSearchSearchStateChanged { + state: i.read()?, + error: i.read()?, + details: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for ChannelTypeContactSearchSearchStateChanged { + const NAME: &'static str = "SearchStateChanged"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Type.ContactSearch"; +} + +#[derive(Debug)] +pub struct ChannelTypeContactSearchSearchResultReceived { + pub result: ::std::collections::HashMap, Vec)>>, +} + +impl arg::AppendAll for ChannelTypeContactSearchSearchResultReceived { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.result, i); + } +} + +impl arg::ReadAll for ChannelTypeContactSearchSearchResultReceived { + fn read(i: &mut arg::Iter) -> Result { + Ok(ChannelTypeContactSearchSearchResultReceived { result: i.read()? }) + } +} + +impl dbus::message::SignalArgs for ChannelTypeContactSearchSearchResultReceived { + const NAME: &'static str = "SearchResultReceived"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Type.ContactSearch"; +} diff --git a/src/telepathy/channel_type_dbus_tube.rs b/src/telepathy/channel_type_dbus_tube.rs new file mode 100644 index 0000000..7e1a7fa --- /dev/null +++ b/src/telepathy/channel_type_dbus_tube.rs @@ -0,0 +1,131 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Type_DBus_Tube.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_type_dbus_tube.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ChannelTypeDBusTube { + fn offer( + &self, + parameters: ::std::collections::HashMap<&str, arg::Variant>>, + access_control: u32, + ) -> Result; + fn accept(&self, access_control: u32) -> Result; + fn service_name(&self) -> Result; + fn dbus_names(&self) -> Result<::std::collections::HashMap, tree::MethodErr>; + fn supported_access_controls(&self) -> Result, tree::MethodErr>; +} + +pub fn channel_type_dbus_tube_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + D::Signal: Default, + T: ChannelTypeDBusTube, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface("org.freedesktop.Telepathy.Channel.Type.DBusTube", data); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let parameters: ::std::collections::HashMap<&str, arg::Variant>> = + i.read()?; + let access_control: u32 = i.read()?; + let d = fclone(minfo); + let address = d.offer(parameters, access_control)?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(address); + Ok(vec![rm]) + }; + let m = factory.method("Offer", Default::default(), h); + let m = m.in_arg(("parameters", "a{sv}")); + let m = m.in_arg(("access_control", "u")); + let m = m.out_arg(("address", "s")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let access_control: u32 = i.read()?; + let d = fclone(minfo); + let address = d.accept(access_control)?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(address); + Ok(vec![rm]) + }; + let m = factory.method("Accept", Default::default(), h); + let m = m.in_arg(("access_control", "u")); + let m = m.out_arg(("address", "s")); + let i = i.add_m(m); + + let p = factory.property::<&str, _>("ServiceName", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.service_name()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory + .property::<::std::collections::HashMap, _>("DBusNames", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.dbus_names()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::, _>("SupportedAccessControls", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.supported_access_controls()?); + Ok(()) + }); + let i = i.add_p(p); + let s = factory.signal("DBusNamesChanged", Default::default()); + let s = s.arg(("Added", "a{us}")); + let s = s.arg(("Removed", "au")); + let i = i.add_s(s); + i +} + +#[derive(Debug)] +pub struct ChannelTypeDBusTubeDBusNamesChanged { + pub added: ::std::collections::HashMap, + pub removed: Vec, +} + +impl arg::AppendAll for ChannelTypeDBusTubeDBusNamesChanged { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.added, i); + arg::RefArg::append(&self.removed, i); + } +} + +impl arg::ReadAll for ChannelTypeDBusTubeDBusNamesChanged { + fn read(i: &mut arg::Iter) -> Result { + Ok(ChannelTypeDBusTubeDBusNamesChanged { + added: i.read()?, + removed: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for ChannelTypeDBusTubeDBusNamesChanged { + const NAME: &'static str = "DBusNamesChanged"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Type.DBusTube"; +} diff --git a/src/telepathy/channel_type_file_transfer.rs b/src/telepathy/channel_type_file_transfer.rs new file mode 100644 index 0000000..eaa1bed --- /dev/null +++ b/src/telepathy/channel_type_file_transfer.rs @@ -0,0 +1,354 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Type_File_Transfer.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_type_file_transfer.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ChannelTypeFileTransfer { + fn accept_file( + &self, + address_type: u32, + access_control: u32, + access_control_param: arg::Variant>, + offset: u64, + ) -> Result>, tree::MethodErr>; + fn provide_file( + &self, + address_type: u32, + access_control: u32, + access_control_param: arg::Variant>, + ) -> Result>, tree::MethodErr>; + fn state(&self) -> Result; + fn content_type(&self) -> Result; + fn filename(&self) -> Result; + fn size(&self) -> Result; + fn content_hash_type(&self) -> Result; + fn content_hash(&self) -> Result; + fn description(&self) -> Result; + fn date(&self) -> Result; + fn available_socket_types( + &self, + ) -> Result<::std::collections::HashMap>, tree::MethodErr>; + fn transferred_bytes(&self) -> Result; + fn initial_offset(&self) -> Result; + fn uri(&self) -> Result; + fn set_uri(&self, value: String) -> Result<(), tree::MethodErr>; + fn file_collection(&self) -> Result; +} + +pub fn channel_type_file_transfer_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + D::Signal: Default, + T: ChannelTypeFileTransfer, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface("org.freedesktop.Telepathy.Channel.Type.FileTransfer", data); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let address_type: u32 = i.read()?; + let access_control: u32 = i.read()?; + let access_control_param: arg::Variant> = i.read()?; + let offset: u64 = i.read()?; + let d = fclone(minfo); + let address = d.accept_file(address_type, access_control, access_control_param, offset)?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(address); + Ok(vec![rm]) + }; + let m = factory.method("AcceptFile", Default::default(), h); + let m = m.in_arg(("Address_Type", "u")); + let m = m.in_arg(("Access_Control", "u")); + let m = m.in_arg(("Access_Control_Param", "v")); + let m = m.in_arg(("Offset", "t")); + let m = m.out_arg(("Address", "v")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let address_type: u32 = i.read()?; + let access_control: u32 = i.read()?; + let access_control_param: arg::Variant> = i.read()?; + let d = fclone(minfo); + let address = d.provide_file(address_type, access_control, access_control_param)?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(address); + Ok(vec![rm]) + }; + let m = factory.method("ProvideFile", Default::default(), h); + let m = m.in_arg(("Address_Type", "u")); + let m = m.in_arg(("Access_Control", "u")); + let m = m.in_arg(("Access_Control_Param", "v")); + let m = m.out_arg(("Address", "v")); + let i = i.add_m(m); + + let p = factory.property::("State", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.state()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::<&str, _>("ContentType", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.content_type()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::<&str, _>("Filename", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.filename()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("Size", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.size()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("ContentHashType", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.content_hash_type()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::<&str, _>("ContentHash", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.content_hash()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::<&str, _>("Description", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.description()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("Date", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.date()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::<::std::collections::HashMap>, _>( + "AvailableSocketTypes", + Default::default(), + ); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.available_socket_types()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("TransferredBytes", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.transferred_bytes()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("InitialOffset", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.initial_offset()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::<&str, _>("URI", Default::default()); + let p = p.access(tree::Access::ReadWrite); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.uri()?); + Ok(()) + }); + let fclone = f.clone(); + let p = p.on_set(move |iter, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + d.set_uri(iter.read()?)?; + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::<&str, _>("FileCollection", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.file_collection()?); + Ok(()) + }); + let i = i.add_p(p); + let s = factory.signal("FileTransferStateChanged", Default::default()); + let s = s.arg(("State", "u")); + let s = s.arg(("Reason", "u")); + let i = i.add_s(s); + let s = factory.signal("TransferredBytesChanged", Default::default()); + let s = s.arg(("Count", "t")); + let i = i.add_s(s); + let s = factory.signal("InitialOffsetDefined", Default::default()); + let s = s.arg(("InitialOffset", "t")); + let i = i.add_s(s); + let s = factory.signal("URIDefined", Default::default()); + let s = s.arg(("URI", "s")); + let i = i.add_s(s); + i +} + +#[derive(Debug)] +pub struct ChannelTypeFileTransferFileTransferStateChanged { + pub state: u32, + pub reason: u32, +} + +impl arg::AppendAll for ChannelTypeFileTransferFileTransferStateChanged { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.state, i); + arg::RefArg::append(&self.reason, i); + } +} + +impl arg::ReadAll for ChannelTypeFileTransferFileTransferStateChanged { + fn read(i: &mut arg::Iter) -> Result { + Ok(ChannelTypeFileTransferFileTransferStateChanged { + state: i.read()?, + reason: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for ChannelTypeFileTransferFileTransferStateChanged { + const NAME: &'static str = "FileTransferStateChanged"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Type.FileTransfer"; +} + +#[derive(Debug)] +pub struct ChannelTypeFileTransferTransferredBytesChanged { + pub count: u64, +} + +impl arg::AppendAll for ChannelTypeFileTransferTransferredBytesChanged { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.count, i); + } +} + +impl arg::ReadAll for ChannelTypeFileTransferTransferredBytesChanged { + fn read(i: &mut arg::Iter) -> Result { + Ok(ChannelTypeFileTransferTransferredBytesChanged { count: i.read()? }) + } +} + +impl dbus::message::SignalArgs for ChannelTypeFileTransferTransferredBytesChanged { + const NAME: &'static str = "TransferredBytesChanged"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Type.FileTransfer"; +} + +#[derive(Debug)] +pub struct ChannelTypeFileTransferInitialOffsetDefined { + pub initial_offset: u64, +} + +impl arg::AppendAll for ChannelTypeFileTransferInitialOffsetDefined { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.initial_offset, i); + } +} + +impl arg::ReadAll for ChannelTypeFileTransferInitialOffsetDefined { + fn read(i: &mut arg::Iter) -> Result { + Ok(ChannelTypeFileTransferInitialOffsetDefined { + initial_offset: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for ChannelTypeFileTransferInitialOffsetDefined { + const NAME: &'static str = "InitialOffsetDefined"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Type.FileTransfer"; +} + +#[derive(Debug)] +pub struct ChannelTypeFileTransferURIDefined { + pub uri: String, +} + +impl arg::AppendAll for ChannelTypeFileTransferURIDefined { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.uri, i); + } +} + +impl arg::ReadAll for ChannelTypeFileTransferURIDefined { + fn read(i: &mut arg::Iter) -> Result { + Ok(ChannelTypeFileTransferURIDefined { uri: i.read()? }) + } +} + +impl dbus::message::SignalArgs for ChannelTypeFileTransferURIDefined { + const NAME: &'static str = "URIDefined"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Type.FileTransfer"; +} diff --git a/src/telepathy/channel_type_room_list.rs b/src/telepathy/channel_type_room_list.rs new file mode 100644 index 0000000..fe06c2a --- /dev/null +++ b/src/telepathy/channel_type_room_list.rs @@ -0,0 +1,125 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Type_Room_List.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_type_room_list.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ChannelTypeRoomList { + fn get_listing_rooms(&self) -> Result; + fn list_rooms(&self) -> Result<(), tree::MethodErr>; + fn stop_listing(&self) -> Result<(), tree::MethodErr>; + fn server(&self) -> Result; +} + +pub fn channel_type_room_list_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + D::Signal: Default, + T: ChannelTypeRoomList, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface("org.freedesktop.Telepathy.Channel.Type.RoomList", data); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let d = fclone(minfo); + let in_progress = d.get_listing_rooms()?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(in_progress); + Ok(vec![rm]) + }; + let m = factory.method("GetListingRooms", Default::default(), h); + let m = m.out_arg(("In_Progress", "b")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let d = fclone(minfo); + d.list_rooms()?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("ListRooms", Default::default(), h); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let d = fclone(minfo); + d.stop_listing()?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("StopListing", Default::default(), h); + let i = i.add_m(m); + + let p = factory.property::<&str, _>("Server", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.server()?); + Ok(()) + }); + let i = i.add_p(p); + let s = factory.signal("GotRooms", Default::default()); + let s = s.arg(("Rooms", "a(usa{sv})")); + let i = i.add_s(s); + let s = factory.signal("ListingRooms", Default::default()); + let s = s.arg(("Listing", "b")); + let i = i.add_s(s); + i +} + +#[derive(Debug)] +pub struct ChannelTypeRoomListGotRooms { + pub rooms: Vec<( + u32, + String, + ::std::collections::HashMap>>, + )>, +} + +impl arg::AppendAll for ChannelTypeRoomListGotRooms { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.rooms, i); + } +} + +impl arg::ReadAll for ChannelTypeRoomListGotRooms { + fn read(i: &mut arg::Iter) -> Result { + Ok(ChannelTypeRoomListGotRooms { rooms: i.read()? }) + } +} + +impl dbus::message::SignalArgs for ChannelTypeRoomListGotRooms { + const NAME: &'static str = "GotRooms"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Type.RoomList"; +} + +#[derive(Debug)] +pub struct ChannelTypeRoomListListingRooms { + pub listing: bool, +} + +impl arg::AppendAll for ChannelTypeRoomListListingRooms { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.listing, i); + } +} + +impl arg::ReadAll for ChannelTypeRoomListListingRooms { + fn read(i: &mut arg::Iter) -> Result { + Ok(ChannelTypeRoomListListingRooms { listing: i.read()? }) + } +} + +impl dbus::message::SignalArgs for ChannelTypeRoomListListingRooms { + const NAME: &'static str = "ListingRooms"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Type.RoomList"; +} diff --git a/src/telepathy/channel_type_server_authentication.rs b/src/telepathy/channel_type_server_authentication.rs new file mode 100644 index 0000000..0a6d57b --- /dev/null +++ b/src/telepathy/channel_type_server_authentication.rs @@ -0,0 +1,38 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Type_Server_Authentication.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_type_server_authentication.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ChannelTypeServerAuthentication { + fn authentication_method(&self) -> Result; +} + +pub fn channel_type_server_authentication_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + T: ChannelTypeServerAuthentication, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface( + "org.freedesktop.Telepathy.Channel.Type.ServerAuthentication", + data, + ); + let f = ::std::sync::Arc::new(f); + let p = factory.property::<&str, _>("AuthenticationMethod", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.authentication_method()?); + Ok(()) + }); + let i = i.add_p(p); + i +} diff --git a/src/telepathy/channel_type_server_tls_connection.rs b/src/telepathy/channel_type_server_tls_connection.rs new file mode 100644 index 0000000..114e555 --- /dev/null +++ b/src/telepathy/channel_type_server_tls_connection.rs @@ -0,0 +1,62 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Type_Server_TLS_Connection.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_type_server_tls_connection.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ChannelTypeServerTLSConnection { + fn server_certificate(&self) -> Result, tree::MethodErr>; + fn hostname(&self) -> Result; + fn reference_identities(&self) -> Result, tree::MethodErr>; +} + +pub fn channel_type_server_tlsconnection_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + T: ChannelTypeServerTLSConnection, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface( + "org.freedesktop.Telepathy.Channel.Type.ServerTLSConnection", + data, + ); + let f = ::std::sync::Arc::new(f); + let p = factory.property::("ServerCertificate", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.server_certificate()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::<&str, _>("Hostname", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.hostname()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::, _>("ReferenceIdentities", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.reference_identities()?); + Ok(()) + }); + let i = i.add_p(p); + i +} diff --git a/src/telepathy/channel_type_stream_tube.rs b/src/telepathy/channel_type_stream_tube.rs new file mode 100644 index 0000000..421f24a --- /dev/null +++ b/src/telepathy/channel_type_stream_tube.rs @@ -0,0 +1,202 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Type_Stream_Tube.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_type_stream_tube.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ChannelTypeStreamTube { + fn offer( + &self, + address_type: u32, + address: arg::Variant>, + access_control: u32, + parameters: ::std::collections::HashMap<&str, arg::Variant>>, + ) -> Result<(), tree::MethodErr>; + fn accept( + &self, + address_type: u32, + access_control: u32, + access_control_param: arg::Variant>, + ) -> Result>, tree::MethodErr>; + fn service(&self) -> Result; + fn supported_socket_types( + &self, + ) -> Result<::std::collections::HashMap>, tree::MethodErr>; +} + +pub fn channel_type_stream_tube_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + D::Signal: Default, + T: ChannelTypeStreamTube, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface("org.freedesktop.Telepathy.Channel.Type.StreamTube", data); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let address_type: u32 = i.read()?; + let address: arg::Variant> = i.read()?; + let access_control: u32 = i.read()?; + let parameters: ::std::collections::HashMap<&str, arg::Variant>> = + i.read()?; + let d = fclone(minfo); + d.offer(address_type, address, access_control, parameters)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("Offer", Default::default(), h); + let m = m.in_arg(("address_type", "u")); + let m = m.in_arg(("address", "v")); + let m = m.in_arg(("access_control", "u")); + let m = m.in_arg(("parameters", "a{sv}")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let address_type: u32 = i.read()?; + let access_control: u32 = i.read()?; + let access_control_param: arg::Variant> = i.read()?; + let d = fclone(minfo); + let address = d.accept(address_type, access_control, access_control_param)?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(address); + Ok(vec![rm]) + }; + let m = factory.method("Accept", Default::default(), h); + let m = m.in_arg(("address_type", "u")); + let m = m.in_arg(("access_control", "u")); + let m = m.in_arg(("access_control_param", "v")); + let m = m.out_arg(("address", "v")); + let i = i.add_m(m); + + let p = factory.property::<&str, _>("Service", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.service()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::<::std::collections::HashMap>, _>( + "SupportedSocketTypes", + Default::default(), + ); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.supported_socket_types()?); + Ok(()) + }); + let i = i.add_p(p); + let s = factory.signal("NewRemoteConnection", Default::default()); + let s = s.arg(("Handle", "u")); + let s = s.arg(("Connection_Param", "v")); + let s = s.arg(("Connection_ID", "u")); + let i = i.add_s(s); + let s = factory.signal("NewLocalConnection", Default::default()); + let s = s.arg(("Connection_ID", "u")); + let i = i.add_s(s); + let s = factory.signal("ConnectionClosed", Default::default()); + let s = s.arg(("Connection_ID", "u")); + let s = s.arg(("Error", "s")); + let s = s.arg(("Message", "s")); + let i = i.add_s(s); + i +} + +#[derive(Debug)] +pub struct ChannelTypeStreamTubeNewRemoteConnection { + pub handle: u32, + pub connection_param: arg::Variant>, + pub connection_id: u32, +} + +impl arg::AppendAll for ChannelTypeStreamTubeNewRemoteConnection { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.handle, i); + arg::RefArg::append(&self.connection_param, i); + arg::RefArg::append(&self.connection_id, i); + } +} + +impl arg::ReadAll for ChannelTypeStreamTubeNewRemoteConnection { + fn read(i: &mut arg::Iter) -> Result { + Ok(ChannelTypeStreamTubeNewRemoteConnection { + handle: i.read()?, + connection_param: i.read()?, + connection_id: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for ChannelTypeStreamTubeNewRemoteConnection { + const NAME: &'static str = "NewRemoteConnection"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Type.StreamTube"; +} + +#[derive(Debug)] +pub struct ChannelTypeStreamTubeNewLocalConnection { + pub connection_id: u32, +} + +impl arg::AppendAll for ChannelTypeStreamTubeNewLocalConnection { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.connection_id, i); + } +} + +impl arg::ReadAll for ChannelTypeStreamTubeNewLocalConnection { + fn read(i: &mut arg::Iter) -> Result { + Ok(ChannelTypeStreamTubeNewLocalConnection { + connection_id: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for ChannelTypeStreamTubeNewLocalConnection { + const NAME: &'static str = "NewLocalConnection"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Type.StreamTube"; +} + +#[derive(Debug)] +pub struct ChannelTypeStreamTubeConnectionClosed { + pub connection_id: u32, + pub error: String, + pub message: String, +} + +impl arg::AppendAll for ChannelTypeStreamTubeConnectionClosed { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.connection_id, i); + arg::RefArg::append(&self.error, i); + arg::RefArg::append(&self.message, i); + } +} + +impl arg::ReadAll for ChannelTypeStreamTubeConnectionClosed { + fn read(i: &mut arg::Iter) -> Result { + Ok(ChannelTypeStreamTubeConnectionClosed { + connection_id: i.read()?, + error: i.read()?, + message: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for ChannelTypeStreamTubeConnectionClosed { + const NAME: &'static str = "ConnectionClosed"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Type.StreamTube"; +} diff --git a/src/telepathy/channel_type_streamed_media.rs b/src/telepathy/channel_type_streamed_media.rs new file mode 100644 index 0000000..1437cfa --- /dev/null +++ b/src/telepathy/channel_type_streamed_media.rs @@ -0,0 +1,292 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Type_Streamed_Media.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_type_streamed_media.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ChannelTypeStreamedMedia { + fn list_streams(&self) -> Result, tree::MethodErr>; + fn remove_streams(&self, streams: Vec) -> Result<(), tree::MethodErr>; + fn request_stream_direction( + &self, + stream_id: u32, + stream_direction: u32, + ) -> Result<(), tree::MethodErr>; + fn request_streams( + &self, + contact_handle: u32, + types: Vec, + ) -> Result, tree::MethodErr>; + fn initial_audio(&self) -> Result; + fn initial_video(&self) -> Result; + fn immutable_streams(&self) -> Result; +} + +pub fn channel_type_streamed_media_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + D::Signal: Default, + T: ChannelTypeStreamedMedia, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface("org.freedesktop.Telepathy.Channel.Type.StreamedMedia", data); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let d = fclone(minfo); + let streams = d.list_streams()?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(streams); + Ok(vec![rm]) + }; + let m = factory.method("ListStreams", Default::default(), h); + let m = m.out_arg(("Streams", "a(uuuuuu)")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let streams: Vec = i.read()?; + let d = fclone(minfo); + d.remove_streams(streams)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("RemoveStreams", Default::default(), h); + let m = m.in_arg(("Streams", "au")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let stream_id: u32 = i.read()?; + let stream_direction: u32 = i.read()?; + let d = fclone(minfo); + d.request_stream_direction(stream_id, stream_direction)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("RequestStreamDirection", Default::default(), h); + let m = m.in_arg(("Stream_ID", "u")); + let m = m.in_arg(("Stream_Direction", "u")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let contact_handle: u32 = i.read()?; + let types: Vec = i.read()?; + let d = fclone(minfo); + let streams = d.request_streams(contact_handle, types)?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(streams); + Ok(vec![rm]) + }; + let m = factory.method("RequestStreams", Default::default(), h); + let m = m.in_arg(("Contact_Handle", "u")); + let m = m.in_arg(("Types", "au")); + let m = m.out_arg(("Streams", "a(uuuuuu)")); + let i = i.add_m(m); + + let p = factory.property::("InitialAudio", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.initial_audio()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("InitialVideo", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.initial_video()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("ImmutableStreams", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.immutable_streams()?); + Ok(()) + }); + let i = i.add_p(p); + let s = factory.signal("StreamAdded", Default::default()); + let s = s.arg(("Stream_ID", "u")); + let s = s.arg(("Contact_Handle", "u")); + let s = s.arg(("Stream_Type", "u")); + let i = i.add_s(s); + let s = factory.signal("StreamDirectionChanged", Default::default()); + let s = s.arg(("Stream_ID", "u")); + let s = s.arg(("Stream_Direction", "u")); + let s = s.arg(("Pending_Flags", "u")); + let i = i.add_s(s); + let s = factory.signal("StreamError", Default::default()); + let s = s.arg(("Stream_ID", "u")); + let s = s.arg(("Error_Code", "u")); + let s = s.arg(("Message", "s")); + let i = i.add_s(s); + let s = factory.signal("StreamRemoved", Default::default()); + let s = s.arg(("Stream_ID", "u")); + let i = i.add_s(s); + let s = factory.signal("StreamStateChanged", Default::default()); + let s = s.arg(("Stream_ID", "u")); + let s = s.arg(("Stream_State", "u")); + let i = i.add_s(s); + i +} + +#[derive(Debug)] +pub struct ChannelTypeStreamedMediaStreamAdded { + pub stream_id: u32, + pub contact_handle: u32, + pub stream_type: u32, +} + +impl arg::AppendAll for ChannelTypeStreamedMediaStreamAdded { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.stream_id, i); + arg::RefArg::append(&self.contact_handle, i); + arg::RefArg::append(&self.stream_type, i); + } +} + +impl arg::ReadAll for ChannelTypeStreamedMediaStreamAdded { + fn read(i: &mut arg::Iter) -> Result { + Ok(ChannelTypeStreamedMediaStreamAdded { + stream_id: i.read()?, + contact_handle: i.read()?, + stream_type: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for ChannelTypeStreamedMediaStreamAdded { + const NAME: &'static str = "StreamAdded"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Type.StreamedMedia"; +} + +#[derive(Debug)] +pub struct ChannelTypeStreamedMediaStreamDirectionChanged { + pub stream_id: u32, + pub stream_direction: u32, + pub pending_flags: u32, +} + +impl arg::AppendAll for ChannelTypeStreamedMediaStreamDirectionChanged { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.stream_id, i); + arg::RefArg::append(&self.stream_direction, i); + arg::RefArg::append(&self.pending_flags, i); + } +} + +impl arg::ReadAll for ChannelTypeStreamedMediaStreamDirectionChanged { + fn read(i: &mut arg::Iter) -> Result { + Ok(ChannelTypeStreamedMediaStreamDirectionChanged { + stream_id: i.read()?, + stream_direction: i.read()?, + pending_flags: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for ChannelTypeStreamedMediaStreamDirectionChanged { + const NAME: &'static str = "StreamDirectionChanged"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Type.StreamedMedia"; +} + +#[derive(Debug)] +pub struct ChannelTypeStreamedMediaStreamError { + pub stream_id: u32, + pub error_code: u32, + pub message: String, +} + +impl arg::AppendAll for ChannelTypeStreamedMediaStreamError { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.stream_id, i); + arg::RefArg::append(&self.error_code, i); + arg::RefArg::append(&self.message, i); + } +} + +impl arg::ReadAll for ChannelTypeStreamedMediaStreamError { + fn read(i: &mut arg::Iter) -> Result { + Ok(ChannelTypeStreamedMediaStreamError { + stream_id: i.read()?, + error_code: i.read()?, + message: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for ChannelTypeStreamedMediaStreamError { + const NAME: &'static str = "StreamError"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Type.StreamedMedia"; +} + +#[derive(Debug)] +pub struct ChannelTypeStreamedMediaStreamRemoved { + pub stream_id: u32, +} + +impl arg::AppendAll for ChannelTypeStreamedMediaStreamRemoved { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.stream_id, i); + } +} + +impl arg::ReadAll for ChannelTypeStreamedMediaStreamRemoved { + fn read(i: &mut arg::Iter) -> Result { + Ok(ChannelTypeStreamedMediaStreamRemoved { + stream_id: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for ChannelTypeStreamedMediaStreamRemoved { + const NAME: &'static str = "StreamRemoved"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Type.StreamedMedia"; +} + +#[derive(Debug)] +pub struct ChannelTypeStreamedMediaStreamStateChanged { + pub stream_id: u32, + pub stream_state: u32, +} + +impl arg::AppendAll for ChannelTypeStreamedMediaStreamStateChanged { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.stream_id, i); + arg::RefArg::append(&self.stream_state, i); + } +} + +impl arg::ReadAll for ChannelTypeStreamedMediaStreamStateChanged { + fn read(i: &mut arg::Iter) -> Result { + Ok(ChannelTypeStreamedMediaStreamStateChanged { + stream_id: i.read()?, + stream_state: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for ChannelTypeStreamedMediaStreamStateChanged { + const NAME: &'static str = "StreamStateChanged"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Type.StreamedMedia"; +} diff --git a/src/telepathy/channel_type_text.rs b/src/telepathy/channel_type_text.rs new file mode 100644 index 0000000..6767c25 --- /dev/null +++ b/src/telepathy/channel_type_text.rs @@ -0,0 +1,226 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Type_Text.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_type_text.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ChannelTypeText { + fn acknowledge_pending_messages(&self, ids: Vec) -> Result<(), tree::MethodErr>; + fn get_message_types(&self) -> Result, tree::MethodErr>; + fn list_pending_messages( + &self, + clear: bool, + ) -> Result, tree::MethodErr>; + fn send(&self, type_: u32, text: &str) -> Result<(), tree::MethodErr>; +} + +pub fn channel_type_text_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Signal: Default, + T: ChannelTypeText, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface("org.freedesktop.Telepathy.Channel.Type.Text", data); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let ids: Vec = i.read()?; + let d = fclone(minfo); + d.acknowledge_pending_messages(ids)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("AcknowledgePendingMessages", Default::default(), h); + let m = m.in_arg(("IDs", "au")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let d = fclone(minfo); + let available_types = d.get_message_types()?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(available_types); + Ok(vec![rm]) + }; + let m = factory.method("GetMessageTypes", Default::default(), h); + let m = m.out_arg(("Available_Types", "au")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let clear: bool = i.read()?; + let d = fclone(minfo); + let pending_messages = d.list_pending_messages(clear)?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(pending_messages); + Ok(vec![rm]) + }; + let m = factory.method("ListPendingMessages", Default::default(), h); + let m = m.in_arg(("Clear", "b")); + let m = m.out_arg(("Pending_Messages", "a(uuuuus)")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let type_: u32 = i.read()?; + let text: &str = i.read()?; + let d = fclone(minfo); + d.send(type_, text)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("Send", Default::default(), h); + let m = m.in_arg(("Type", "u")); + let m = m.in_arg(("Text", "s")); + let i = i.add_m(m); + let s = factory.signal("LostMessage", Default::default()); + let i = i.add_s(s); + let s = factory.signal("Received", Default::default()); + let s = s.arg(("ID", "u")); + let s = s.arg(("Timestamp", "u")); + let s = s.arg(("Sender", "u")); + let s = s.arg(("Type", "u")); + let s = s.arg(("Flags", "u")); + let s = s.arg(("Text", "s")); + let i = i.add_s(s); + let s = factory.signal("SendError", Default::default()); + let s = s.arg(("Error", "u")); + let s = s.arg(("Timestamp", "u")); + let s = s.arg(("Type", "u")); + let s = s.arg(("Text", "s")); + let i = i.add_s(s); + let s = factory.signal("Sent", Default::default()); + let s = s.arg(("Timestamp", "u")); + let s = s.arg(("Type", "u")); + let s = s.arg(("Text", "s")); + let i = i.add_s(s); + i +} + +#[derive(Debug)] +pub struct ChannelTypeTextLostMessage {} + +impl arg::AppendAll for ChannelTypeTextLostMessage { + fn append(&self, _: &mut arg::IterAppend) {} +} + +impl arg::ReadAll for ChannelTypeTextLostMessage { + fn read(_: &mut arg::Iter) -> Result { + Ok(ChannelTypeTextLostMessage {}) + } +} + +impl dbus::message::SignalArgs for ChannelTypeTextLostMessage { + const NAME: &'static str = "LostMessage"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Type.Text"; +} + +#[derive(Debug)] +pub struct ChannelTypeTextReceived { + pub id: u32, + pub timestamp: u32, + pub sender: u32, + pub type_: u32, + pub flags: u32, + pub text: String, +} + +impl arg::AppendAll for ChannelTypeTextReceived { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.id, i); + arg::RefArg::append(&self.timestamp, i); + arg::RefArg::append(&self.sender, i); + arg::RefArg::append(&self.type_, i); + arg::RefArg::append(&self.flags, i); + arg::RefArg::append(&self.text, i); + } +} + +impl arg::ReadAll for ChannelTypeTextReceived { + fn read(i: &mut arg::Iter) -> Result { + Ok(ChannelTypeTextReceived { + id: i.read()?, + timestamp: i.read()?, + sender: i.read()?, + type_: i.read()?, + flags: i.read()?, + text: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for ChannelTypeTextReceived { + const NAME: &'static str = "Received"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Type.Text"; +} + +#[derive(Debug)] +pub struct ChannelTypeTextSendError { + pub error: u32, + pub timestamp: u32, + pub type_: u32, + pub text: String, +} + +impl arg::AppendAll for ChannelTypeTextSendError { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.error, i); + arg::RefArg::append(&self.timestamp, i); + arg::RefArg::append(&self.type_, i); + arg::RefArg::append(&self.text, i); + } +} + +impl arg::ReadAll for ChannelTypeTextSendError { + fn read(i: &mut arg::Iter) -> Result { + Ok(ChannelTypeTextSendError { + error: i.read()?, + timestamp: i.read()?, + type_: i.read()?, + text: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for ChannelTypeTextSendError { + const NAME: &'static str = "SendError"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Type.Text"; +} + +#[derive(Debug)] +pub struct ChannelTypeTextSent { + pub timestamp: u32, + pub type_: u32, + pub text: String, +} + +impl arg::AppendAll for ChannelTypeTextSent { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.timestamp, i); + arg::RefArg::append(&self.type_, i); + arg::RefArg::append(&self.text, i); + } +} + +impl arg::ReadAll for ChannelTypeTextSent { + fn read(i: &mut arg::Iter) -> Result { + Ok(ChannelTypeTextSent { + timestamp: i.read()?, + type_: i.read()?, + text: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for ChannelTypeTextSent { + const NAME: &'static str = "Sent"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Type.Text"; +} diff --git a/src/telepathy/channel_type_tubes.rs b/src/telepathy/channel_type_tubes.rs new file mode 100644 index 0000000..733bd67 --- /dev/null +++ b/src/telepathy/channel_type_tubes.rs @@ -0,0 +1,423 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Channel_Type_Tubes.xml -i org.freedesktop.Telepathy -o src/telepathy/channel_type_tubes.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ChannelTypeTubes { + fn get_available_stream_tube_types( + &self, + ) -> Result<::std::collections::HashMap>, tree::MethodErr>; + fn get_available_tube_types(&self) -> Result, tree::MethodErr>; + fn list_tubes( + &self, + ) -> Result< + Vec<( + u32, + u32, + u32, + String, + ::std::collections::HashMap>>, + u32, + )>, + tree::MethodErr, + >; + fn offer_dbus_tube( + &self, + service: &str, + parameters: ::std::collections::HashMap<&str, arg::Variant>>, + ) -> Result; + fn offer_stream_tube( + &self, + service: &str, + parameters: ::std::collections::HashMap<&str, arg::Variant>>, + address_type: u32, + address: arg::Variant>, + access_control: u32, + access_control_param: arg::Variant>, + ) -> Result; + fn accept_dbus_tube(&self, id: u32) -> Result; + fn accept_stream_tube( + &self, + id: u32, + address_type: u32, + access_control: u32, + access_control_param: arg::Variant>, + ) -> Result>, tree::MethodErr>; + fn close_tube(&self, id: u32) -> Result<(), tree::MethodErr>; + fn get_dbus_tube_address(&self, id: u32) -> Result; + fn get_dbus_names(&self, id: u32) -> Result, tree::MethodErr>; + fn get_stream_tube_socket_address( + &self, + id: u32, + ) -> Result<(u32, arg::Variant>), tree::MethodErr>; +} + +pub fn channel_type_tubes_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Signal: Default, + T: ChannelTypeTubes, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface("org.freedesktop.Telepathy.Channel.Type.Tubes", data); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let d = fclone(minfo); + let available_stream_tube_types = d.get_available_stream_tube_types()?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(available_stream_tube_types); + Ok(vec![rm]) + }; + let m = factory.method("GetAvailableStreamTubeTypes", Default::default(), h); + let m = m.out_arg(("Available_Stream_Tube_Types", "a{uau}")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let d = fclone(minfo); + let available_tube_types = d.get_available_tube_types()?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(available_tube_types); + Ok(vec![rm]) + }; + let m = factory.method("GetAvailableTubeTypes", Default::default(), h); + let m = m.out_arg(("Available_Tube_Types", "au")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let d = fclone(minfo); + let tubes = d.list_tubes()?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(tubes); + Ok(vec![rm]) + }; + let m = factory.method("ListTubes", Default::default(), h); + let m = m.out_arg(("Tubes", "a(uuusa{sv}u)")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let service: &str = i.read()?; + let parameters: ::std::collections::HashMap<&str, arg::Variant>> = + i.read()?; + let d = fclone(minfo); + let tube_id = d.offer_dbus_tube(service, parameters)?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(tube_id); + Ok(vec![rm]) + }; + let m = factory.method("OfferDBusTube", Default::default(), h); + let m = m.in_arg(("Service", "s")); + let m = m.in_arg(("Parameters", "a{sv}")); + let m = m.out_arg(("Tube_ID", "u")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let service: &str = i.read()?; + let parameters: ::std::collections::HashMap<&str, arg::Variant>> = + i.read()?; + let address_type: u32 = i.read()?; + let address: arg::Variant> = i.read()?; + let access_control: u32 = i.read()?; + let access_control_param: arg::Variant> = i.read()?; + let d = fclone(minfo); + let tube_id = d.offer_stream_tube( + service, + parameters, + address_type, + address, + access_control, + access_control_param, + )?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(tube_id); + Ok(vec![rm]) + }; + let m = factory.method("OfferStreamTube", Default::default(), h); + let m = m.in_arg(("Service", "s")); + let m = m.in_arg(("Parameters", "a{sv}")); + let m = m.in_arg(("Address_Type", "u")); + let m = m.in_arg(("Address", "v")); + let m = m.in_arg(("Access_Control", "u")); + let m = m.in_arg(("Access_Control_Param", "v")); + let m = m.out_arg(("Tube_ID", "u")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let id: u32 = i.read()?; + let d = fclone(minfo); + let address = d.accept_dbus_tube(id)?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(address); + Ok(vec![rm]) + }; + let m = factory.method("AcceptDBusTube", Default::default(), h); + let m = m.in_arg(("ID", "u")); + let m = m.out_arg(("Address", "s")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let id: u32 = i.read()?; + let address_type: u32 = i.read()?; + let access_control: u32 = i.read()?; + let access_control_param: arg::Variant> = i.read()?; + let d = fclone(minfo); + let address = + d.accept_stream_tube(id, address_type, access_control, access_control_param)?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(address); + Ok(vec![rm]) + }; + let m = factory.method("AcceptStreamTube", Default::default(), h); + let m = m.in_arg(("ID", "u")); + let m = m.in_arg(("Address_Type", "u")); + let m = m.in_arg(("Access_Control", "u")); + let m = m.in_arg(("Access_Control_Param", "v")); + let m = m.out_arg(("Address", "v")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let id: u32 = i.read()?; + let d = fclone(minfo); + d.close_tube(id)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("CloseTube", Default::default(), h); + let m = m.in_arg(("ID", "u")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let id: u32 = i.read()?; + let d = fclone(minfo); + let address = d.get_dbus_tube_address(id)?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(address); + Ok(vec![rm]) + }; + let m = factory.method("GetDBusTubeAddress", Default::default(), h); + let m = m.in_arg(("ID", "u")); + let m = m.out_arg(("Address", "s")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let id: u32 = i.read()?; + let d = fclone(minfo); + let dbus_names = d.get_dbus_names(id)?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(dbus_names); + Ok(vec![rm]) + }; + let m = factory.method("GetDBusNames", Default::default(), h); + let m = m.in_arg(("ID", "u")); + let m = m.out_arg(("DBus_Names", "a(us)")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let id: u32 = i.read()?; + let d = fclone(minfo); + let (address_type, address) = d.get_stream_tube_socket_address(id)?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(address_type); + let rm = rm.append1(address); + Ok(vec![rm]) + }; + let m = factory.method("GetStreamTubeSocketAddress", Default::default(), h); + let m = m.in_arg(("ID", "u")); + let m = m.out_arg(("Address_Type", "u")); + let m = m.out_arg(("Address", "v")); + let i = i.add_m(m); + let s = factory.signal("NewTube", Default::default()); + let s = s.arg(("ID", "u")); + let s = s.arg(("Initiator", "u")); + let s = s.arg(("Type", "u")); + let s = s.arg(("Service", "s")); + let s = s.arg(("Parameters", "a{sv}")); + let s = s.arg(("State", "u")); + let i = i.add_s(s); + let s = factory.signal("TubeStateChanged", Default::default()); + let s = s.arg(("ID", "u")); + let s = s.arg(("State", "u")); + let i = i.add_s(s); + let s = factory.signal("TubeClosed", Default::default()); + let s = s.arg(("ID", "u")); + let i = i.add_s(s); + let s = factory.signal("DBusNamesChanged", Default::default()); + let s = s.arg(("ID", "u")); + let s = s.arg(("Added", "a(us)")); + let s = s.arg(("Removed", "au")); + let i = i.add_s(s); + let s = factory.signal("StreamTubeNewConnection", Default::default()); + let s = s.arg(("ID", "u")); + let s = s.arg(("Handle", "u")); + let i = i.add_s(s); + i +} + +#[derive(Debug)] +pub struct ChannelTypeTubesNewTube { + pub id: u32, + pub initiator: u32, + pub type_: u32, + pub service: String, + pub parameters: + ::std::collections::HashMap>>, + pub state: u32, +} + +impl arg::AppendAll for ChannelTypeTubesNewTube { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.id, i); + arg::RefArg::append(&self.initiator, i); + arg::RefArg::append(&self.type_, i); + arg::RefArg::append(&self.service, i); + arg::RefArg::append(&self.parameters, i); + arg::RefArg::append(&self.state, i); + } +} + +impl arg::ReadAll for ChannelTypeTubesNewTube { + fn read(i: &mut arg::Iter) -> Result { + Ok(ChannelTypeTubesNewTube { + id: i.read()?, + initiator: i.read()?, + type_: i.read()?, + service: i.read()?, + parameters: i.read()?, + state: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for ChannelTypeTubesNewTube { + const NAME: &'static str = "NewTube"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Type.Tubes"; +} + +#[derive(Debug)] +pub struct ChannelTypeTubesTubeStateChanged { + pub id: u32, + pub state: u32, +} + +impl arg::AppendAll for ChannelTypeTubesTubeStateChanged { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.id, i); + arg::RefArg::append(&self.state, i); + } +} + +impl arg::ReadAll for ChannelTypeTubesTubeStateChanged { + fn read(i: &mut arg::Iter) -> Result { + Ok(ChannelTypeTubesTubeStateChanged { + id: i.read()?, + state: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for ChannelTypeTubesTubeStateChanged { + const NAME: &'static str = "TubeStateChanged"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Type.Tubes"; +} + +#[derive(Debug)] +pub struct ChannelTypeTubesTubeClosed { + pub id: u32, +} + +impl arg::AppendAll for ChannelTypeTubesTubeClosed { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.id, i); + } +} + +impl arg::ReadAll for ChannelTypeTubesTubeClosed { + fn read(i: &mut arg::Iter) -> Result { + Ok(ChannelTypeTubesTubeClosed { id: i.read()? }) + } +} + +impl dbus::message::SignalArgs for ChannelTypeTubesTubeClosed { + const NAME: &'static str = "TubeClosed"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Type.Tubes"; +} + +#[derive(Debug)] +pub struct ChannelTypeTubesDBusNamesChanged { + pub id: u32, + pub added: Vec<(u32, String)>, + pub removed: Vec, +} + +impl arg::AppendAll for ChannelTypeTubesDBusNamesChanged { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.id, i); + arg::RefArg::append(&self.added, i); + arg::RefArg::append(&self.removed, i); + } +} + +impl arg::ReadAll for ChannelTypeTubesDBusNamesChanged { + fn read(i: &mut arg::Iter) -> Result { + Ok(ChannelTypeTubesDBusNamesChanged { + id: i.read()?, + added: i.read()?, + removed: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for ChannelTypeTubesDBusNamesChanged { + const NAME: &'static str = "DBusNamesChanged"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Type.Tubes"; +} + +#[derive(Debug)] +pub struct ChannelTypeTubesStreamTubeNewConnection { + pub id: u32, + pub handle: u32, +} + +impl arg::AppendAll for ChannelTypeTubesStreamTubeNewConnection { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.id, i); + arg::RefArg::append(&self.handle, i); + } +} + +impl arg::ReadAll for ChannelTypeTubesStreamTubeNewConnection { + fn read(i: &mut arg::Iter) -> Result { + Ok(ChannelTypeTubesStreamTubeNewConnection { + id: i.read()?, + handle: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for ChannelTypeTubesStreamTubeNewConnection { + const NAME: &'static str = "StreamTubeNewConnection"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Channel.Type.Tubes"; +} diff --git a/src/telepathy/client.rs b/src/telepathy/client.rs new file mode 100644 index 0000000..a16666e --- /dev/null +++ b/src/telepathy/client.rs @@ -0,0 +1,35 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Client.xml -i org.freedesktop.Telepathy -o src/telepathy/client.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait Client { + fn interfaces(&self) -> Result, tree::MethodErr>; +} + +pub fn client_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + T: Client, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface("org.freedesktop.Telepathy.Client", data); + let f = ::std::sync::Arc::new(f); + let p = factory.property::, _>("Interfaces", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.interfaces()?); + Ok(()) + }); + let i = i.add_p(p); + i +} diff --git a/src/telepathy/client_approver.rs b/src/telepathy/client_approver.rs new file mode 100644 index 0000000..bf0218b --- /dev/null +++ b/src/telepathy/client_approver.rs @@ -0,0 +1,74 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Client_Approver.xml -i org.freedesktop.Telepathy -o src/telepathy/client_approver.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ClientApprover { + fn add_dispatch_operation( + &self, + channels: Vec<( + dbus::Path, + ::std::collections::HashMap<&str, arg::Variant>>, + )>, + dispatch_operation: dbus::Path, + properties: ::std::collections::HashMap<&str, arg::Variant>>, + ) -> Result<(), tree::MethodErr>; + fn approver_channel_filter( + &self, + ) -> Result< + Vec<::std::collections::HashMap>>>, + tree::MethodErr, + >; +} + +pub fn client_approver_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + T: ClientApprover, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface("org.freedesktop.Telepathy.Client.Approver", data); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let channels: Vec<( + dbus::Path, + ::std::collections::HashMap<&str, arg::Variant>>, + )> = i.read()?; + let dispatch_operation: dbus::Path = i.read()?; + let properties: ::std::collections::HashMap<&str, arg::Variant>> = + i.read()?; + let d = fclone(minfo); + d.add_dispatch_operation(channels, dispatch_operation, properties)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("AddDispatchOperation", Default::default(), h); + let m = m.in_arg(("Channels", "a(oa{sv})")); + let m = m.in_arg(("DispatchOperation", "o")); + let m = m.in_arg(("Properties", "a{sv}")); + let i = i.add_m(m); + + let p = factory + .property::>>>, _>( + "ApproverChannelFilter", + Default::default(), + ); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.approver_channel_filter()?); + Ok(()) + }); + let i = i.add_p(p); + i +} diff --git a/src/telepathy/client_handler.rs b/src/telepathy/client_handler.rs new file mode 100644 index 0000000..a0e3e72 --- /dev/null +++ b/src/telepathy/client_handler.rs @@ -0,0 +1,126 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Client_Handler.xml -i org.freedesktop.Telepathy -o src/telepathy/client_handler.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ClientHandler { + fn handle_channels( + &self, + account: dbus::Path, + connection: dbus::Path, + channels: Vec<( + dbus::Path, + ::std::collections::HashMap<&str, arg::Variant>>, + )>, + requests_satisfied: Vec, + user_action_time: u64, + handler_info: ::std::collections::HashMap<&str, arg::Variant>>, + ) -> Result<(), tree::MethodErr>; + fn handler_channel_filter( + &self, + ) -> Result< + Vec<::std::collections::HashMap>>>, + tree::MethodErr, + >; + fn bypass_approval(&self) -> Result; + fn capabilities(&self) -> Result, tree::MethodErr>; + fn handled_channels(&self) -> Result>, tree::MethodErr>; +} + +pub fn client_handler_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + T: ClientHandler, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface("org.freedesktop.Telepathy.Client.Handler", data); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let account: dbus::Path = i.read()?; + let connection: dbus::Path = i.read()?; + let channels: Vec<( + dbus::Path, + ::std::collections::HashMap<&str, arg::Variant>>, + )> = i.read()?; + let requests_satisfied: Vec = i.read()?; + let user_action_time: u64 = i.read()?; + let handler_info: ::std::collections::HashMap<&str, arg::Variant>> = + i.read()?; + let d = fclone(minfo); + d.handle_channels( + account, + connection, + channels, + requests_satisfied, + user_action_time, + handler_info, + )?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("HandleChannels", Default::default(), h); + let m = m.in_arg(("Account", "o")); + let m = m.in_arg(("Connection", "o")); + let m = m.in_arg(("Channels", "a(oa{sv})")); + let m = m.in_arg(("Requests_Satisfied", "ao")); + let m = m.in_arg(("User_Action_Time", "t")); + let m = m.in_arg(("Handler_Info", "a{sv}")); + let i = i.add_m(m); + + let p = factory + .property::>>>, _>( + "HandlerChannelFilter", + Default::default(), + ); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.handler_channel_filter()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("BypassApproval", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.bypass_approval()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::, _>("Capabilities", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.capabilities()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::, _>("HandledChannels", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.handled_channels()?); + Ok(()) + }); + let i = i.add_p(p); + i +} diff --git a/src/telepathy/client_handler_future.rs b/src/telepathy/client_handler_future.rs new file mode 100644 index 0000000..02a266d --- /dev/null +++ b/src/telepathy/client_handler_future.rs @@ -0,0 +1,47 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Client_Handler_Future.xml -i org.freedesktop.Telepathy -o src/telepathy/client_handler_future.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ClientHandlerFUTURE { + fn bypass_observers(&self) -> Result; + fn related_conferences_bypass_approval(&self) -> Result; +} + +pub fn client_handler_future_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + T: ClientHandlerFUTURE, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface("org.freedesktop.Telepathy.Client.Handler.FUTURE", data); + let f = ::std::sync::Arc::new(f); + let p = factory.property::("BypassObservers", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.bypass_observers()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("RelatedConferencesBypassApproval", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.related_conferences_bypass_approval()?); + Ok(()) + }); + let i = i.add_p(p); + i +} diff --git a/src/telepathy/client_interface_requests.rs b/src/telepathy/client_interface_requests.rs new file mode 100644 index 0000000..a331730 --- /dev/null +++ b/src/telepathy/client_interface_requests.rs @@ -0,0 +1,66 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Client_Interface_Requests.xml -i org.freedesktop.Telepathy -o src/telepathy/client_interface_requests.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ClientInterfaceRequests { + fn add_request( + &self, + request: dbus::Path, + properties: ::std::collections::HashMap<&str, arg::Variant>>, + ) -> Result<(), tree::MethodErr>; + fn remove_request( + &self, + request: dbus::Path, + error: &str, + message: &str, + ) -> Result<(), tree::MethodErr>; +} + +pub fn client_interface_requests_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + T: ClientInterfaceRequests, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface("org.freedesktop.Telepathy.Client.Interface.Requests", data); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let request: dbus::Path = i.read()?; + let properties: ::std::collections::HashMap<&str, arg::Variant>> = + i.read()?; + let d = fclone(minfo); + d.add_request(request, properties)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("AddRequest", Default::default(), h); + let m = m.in_arg(("Request", "o")); + let m = m.in_arg(("Properties", "a{sv}")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let request: dbus::Path = i.read()?; + let error: &str = i.read()?; + let message: &str = i.read()?; + let d = fclone(minfo); + d.remove_request(request, error, message)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("RemoveRequest", Default::default(), h); + let m = m.in_arg(("Request", "o")); + let m = m.in_arg(("Error", "s")); + let m = m.in_arg(("Message", "s")); + let i = i.add_m(m); + i +} diff --git a/src/telepathy/client_observer.rs b/src/telepathy/client_observer.rs new file mode 100644 index 0000000..f08c477 --- /dev/null +++ b/src/telepathy/client_observer.rs @@ -0,0 +1,114 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Client_Observer.xml -i org.freedesktop.Telepathy -o src/telepathy/client_observer.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ClientObserver { + fn observe_channels( + &self, + account: dbus::Path, + connection: dbus::Path, + channels: Vec<( + dbus::Path, + ::std::collections::HashMap<&str, arg::Variant>>, + )>, + dispatch_operation: dbus::Path, + requests_satisfied: Vec, + observer_info: ::std::collections::HashMap<&str, arg::Variant>>, + ) -> Result<(), tree::MethodErr>; + fn observer_channel_filter( + &self, + ) -> Result< + Vec<::std::collections::HashMap>>>, + tree::MethodErr, + >; + fn recover(&self) -> Result; + fn delay_approvers(&self) -> Result; +} + +pub fn client_observer_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + T: ClientObserver, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface("org.freedesktop.Telepathy.Client.Observer", data); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let account: dbus::Path = i.read()?; + let connection: dbus::Path = i.read()?; + let channels: Vec<( + dbus::Path, + ::std::collections::HashMap<&str, arg::Variant>>, + )> = i.read()?; + let dispatch_operation: dbus::Path = i.read()?; + let requests_satisfied: Vec = i.read()?; + let observer_info: ::std::collections::HashMap<&str, arg::Variant>> = + i.read()?; + let d = fclone(minfo); + d.observe_channels( + account, + connection, + channels, + dispatch_operation, + requests_satisfied, + observer_info, + )?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("ObserveChannels", Default::default(), h); + let m = m.in_arg(("Account", "o")); + let m = m.in_arg(("Connection", "o")); + let m = m.in_arg(("Channels", "a(oa{sv})")); + let m = m.in_arg(("Dispatch_Operation", "o")); + let m = m.in_arg(("Requests_Satisfied", "ao")); + let m = m.in_arg(("Observer_Info", "a{sv}")); + let i = i.add_m(m); + + let p = factory + .property::>>>, _>( + "ObserverChannelFilter", + Default::default(), + ); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.observer_channel_filter()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("Recover", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.recover()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("DelayApprovers", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.delay_approvers()?); + Ok(()) + }); + let i = i.add_p(p); + i +} diff --git a/src/telepathy/connection.rs b/src/telepathy/connection.rs new file mode 100644 index 0000000..8e13431 --- /dev/null +++ b/src/telepathy/connection.rs @@ -0,0 +1,468 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Connection.xml -i org.freedesktop.Telepathy -o src/telepathy/connection.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait Connection { + fn connect(&self) -> Result<(), tree::MethodErr>; + fn disconnect(&self) -> Result<(), tree::MethodErr>; + fn get_interfaces(&self) -> Result, tree::MethodErr>; + fn get_protocol(&self) -> Result; + fn get_self_handle(&self) -> Result; + fn get_status(&self) -> Result; + fn hold_handles(&self, handle_type: u32, handles: Vec) -> Result<(), tree::MethodErr>; + fn inspect_handles( + &self, + handle_type: u32, + handles: Vec, + ) -> Result, tree::MethodErr>; + fn list_channels( + &self, + ) -> Result, String, u32, u32)>, tree::MethodErr>; + fn release_handles(&self, handle_type: u32, handles: Vec) -> Result<(), tree::MethodErr>; + fn request_channel( + &self, + type_: &str, + handle_type: u32, + handle: u32, + suppress_handler: bool, + ) -> Result, tree::MethodErr>; + fn request_handles( + &self, + handle_type: u32, + identifiers: Vec<&str>, + ) -> Result, tree::MethodErr>; + fn add_client_interest(&self, tokens: Vec<&str>) -> Result<(), tree::MethodErr>; + fn remove_client_interest(&self, tokens: Vec<&str>) -> Result<(), tree::MethodErr>; + fn interfaces(&self) -> Result, tree::MethodErr>; + fn self_handle(&self) -> Result; + fn self_id(&self) -> Result; + fn status(&self) -> Result; + fn has_immortal_handles(&self) -> Result; +} + +pub fn connection_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + D::Signal: Default, + T: Connection, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface("org.freedesktop.Telepathy.Connection", data); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let d = fclone(minfo); + d.connect()?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("Connect", Default::default(), h); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let d = fclone(minfo); + d.disconnect()?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("Disconnect", Default::default(), h); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let d = fclone(minfo); + let interfaces = d.get_interfaces()?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(interfaces); + Ok(vec![rm]) + }; + let m = factory.method("GetInterfaces", Default::default(), h); + let m = m.out_arg(("Interfaces", "as")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let d = fclone(minfo); + let protocol = d.get_protocol()?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(protocol); + Ok(vec![rm]) + }; + let m = factory.method("GetProtocol", Default::default(), h); + let m = m.out_arg(("Protocol", "s")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let d = fclone(minfo); + let self_handle = d.get_self_handle()?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(self_handle); + Ok(vec![rm]) + }; + let m = factory.method("GetSelfHandle", Default::default(), h); + let m = m.out_arg(("Self_Handle", "u")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let d = fclone(minfo); + let status = d.get_status()?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(status); + Ok(vec![rm]) + }; + let m = factory.method("GetStatus", Default::default(), h); + let m = m.out_arg(("Status", "u")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let handle_type: u32 = i.read()?; + let handles: Vec = i.read()?; + let d = fclone(minfo); + d.hold_handles(handle_type, handles)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("HoldHandles", Default::default(), h); + let m = m.in_arg(("Handle_Type", "u")); + let m = m.in_arg(("Handles", "au")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let handle_type: u32 = i.read()?; + let handles: Vec = i.read()?; + let d = fclone(minfo); + let identifiers = d.inspect_handles(handle_type, handles)?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(identifiers); + Ok(vec![rm]) + }; + let m = factory.method("InspectHandles", Default::default(), h); + let m = m.in_arg(("Handle_Type", "u")); + let m = m.in_arg(("Handles", "au")); + let m = m.out_arg(("Identifiers", "as")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let d = fclone(minfo); + let channel_info = d.list_channels()?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(channel_info); + Ok(vec![rm]) + }; + let m = factory.method("ListChannels", Default::default(), h); + let m = m.out_arg(("Channel_Info", "a(osuu)")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let handle_type: u32 = i.read()?; + let handles: Vec = i.read()?; + let d = fclone(minfo); + d.release_handles(handle_type, handles)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("ReleaseHandles", Default::default(), h); + let m = m.in_arg(("Handle_Type", "u")); + let m = m.in_arg(("Handles", "au")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let type_: &str = i.read()?; + let handle_type: u32 = i.read()?; + let handle: u32 = i.read()?; + let suppress_handler: bool = i.read()?; + let d = fclone(minfo); + let object_path = d.request_channel(type_, handle_type, handle, suppress_handler)?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(object_path); + Ok(vec![rm]) + }; + let m = factory.method("RequestChannel", Default::default(), h); + let m = m.in_arg(("Type", "s")); + let m = m.in_arg(("Handle_Type", "u")); + let m = m.in_arg(("Handle", "u")); + let m = m.in_arg(("Suppress_Handler", "b")); + let m = m.out_arg(("Object_Path", "o")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let handle_type: u32 = i.read()?; + let identifiers: Vec<&str> = i.read()?; + let d = fclone(minfo); + let handles = d.request_handles(handle_type, identifiers)?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(handles); + Ok(vec![rm]) + }; + let m = factory.method("RequestHandles", Default::default(), h); + let m = m.in_arg(("Handle_Type", "u")); + let m = m.in_arg(("Identifiers", "as")); + let m = m.out_arg(("Handles", "au")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let tokens: Vec<&str> = i.read()?; + let d = fclone(minfo); + d.add_client_interest(tokens)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("AddClientInterest", Default::default(), h); + let m = m.in_arg(("Tokens", "as")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let tokens: Vec<&str> = i.read()?; + let d = fclone(minfo); + d.remove_client_interest(tokens)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("RemoveClientInterest", Default::default(), h); + let m = m.in_arg(("Tokens", "as")); + let i = i.add_m(m); + + let p = factory.property::, _>("Interfaces", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.interfaces()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("SelfHandle", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.self_handle()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::<&str, _>("SelfID", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.self_id()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("Status", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.status()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("HasImmortalHandles", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.has_immortal_handles()?); + Ok(()) + }); + let i = i.add_p(p); + let s = factory.signal("SelfHandleChanged", Default::default()); + let s = s.arg(("Self_Handle", "u")); + let i = i.add_s(s); + let s = factory.signal("SelfContactChanged", Default::default()); + let s = s.arg(("Self_Handle", "u")); + let s = s.arg(("Self_ID", "s")); + let i = i.add_s(s); + let s = factory.signal("NewChannel", Default::default()); + let s = s.arg(("Object_Path", "o")); + let s = s.arg(("Channel_Type", "s")); + let s = s.arg(("Handle_Type", "u")); + let s = s.arg(("Handle", "u")); + let s = s.arg(("Suppress_Handler", "b")); + let i = i.add_s(s); + let s = factory.signal("ConnectionError", Default::default()); + let s = s.arg(("Error", "s")); + let s = s.arg(("Details", "a{sv}")); + let i = i.add_s(s); + let s = factory.signal("StatusChanged", Default::default()); + let s = s.arg(("Status", "u")); + let s = s.arg(("Reason", "u")); + let i = i.add_s(s); + i +} + +#[derive(Debug)] +pub struct ConnectionSelfHandleChanged { + pub self_handle: u32, +} + +impl arg::AppendAll for ConnectionSelfHandleChanged { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.self_handle, i); + } +} + +impl arg::ReadAll for ConnectionSelfHandleChanged { + fn read(i: &mut arg::Iter) -> Result { + Ok(ConnectionSelfHandleChanged { + self_handle: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for ConnectionSelfHandleChanged { + const NAME: &'static str = "SelfHandleChanged"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Connection"; +} + +#[derive(Debug)] +pub struct ConnectionSelfContactChanged { + pub self_handle: u32, + pub self_id: String, +} + +impl arg::AppendAll for ConnectionSelfContactChanged { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.self_handle, i); + arg::RefArg::append(&self.self_id, i); + } +} + +impl arg::ReadAll for ConnectionSelfContactChanged { + fn read(i: &mut arg::Iter) -> Result { + Ok(ConnectionSelfContactChanged { + self_handle: i.read()?, + self_id: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for ConnectionSelfContactChanged { + const NAME: &'static str = "SelfContactChanged"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Connection"; +} + +#[derive(Debug)] +pub struct ConnectionNewChannel { + pub object_path: dbus::Path<'static>, + pub channel_type: String, + pub handle_type: u32, + pub handle: u32, + pub suppress_handler: bool, +} + +impl arg::AppendAll for ConnectionNewChannel { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.object_path, i); + arg::RefArg::append(&self.channel_type, i); + arg::RefArg::append(&self.handle_type, i); + arg::RefArg::append(&self.handle, i); + arg::RefArg::append(&self.suppress_handler, i); + } +} + +impl arg::ReadAll for ConnectionNewChannel { + fn read(i: &mut arg::Iter) -> Result { + Ok(ConnectionNewChannel { + object_path: i.read()?, + channel_type: i.read()?, + handle_type: i.read()?, + handle: i.read()?, + suppress_handler: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for ConnectionNewChannel { + const NAME: &'static str = "NewChannel"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Connection"; +} + +#[derive(Debug)] +pub struct ConnectionConnectionError { + pub error: String, + pub details: ::std::collections::HashMap>>, +} + +impl arg::AppendAll for ConnectionConnectionError { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.error, i); + arg::RefArg::append(&self.details, i); + } +} + +impl arg::ReadAll for ConnectionConnectionError { + fn read(i: &mut arg::Iter) -> Result { + Ok(ConnectionConnectionError { + error: i.read()?, + details: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for ConnectionConnectionError { + const NAME: &'static str = "ConnectionError"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Connection"; +} + +#[derive(Debug)] +pub struct ConnectionStatusChanged { + pub status: u32, + pub reason: u32, +} + +impl arg::AppendAll for ConnectionStatusChanged { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.status, i); + arg::RefArg::append(&self.reason, i); + } +} + +impl arg::ReadAll for ConnectionStatusChanged { + fn read(i: &mut arg::Iter) -> Result { + Ok(ConnectionStatusChanged { + status: i.read()?, + reason: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for ConnectionStatusChanged { + const NAME: &'static str = "StatusChanged"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Connection"; +} diff --git a/src/telepathy/connection_interface_addressing.rs b/src/telepathy/connection_interface_addressing.rs new file mode 100644 index 0000000..d2a1608 --- /dev/null +++ b/src/telepathy/connection_interface_addressing.rs @@ -0,0 +1,95 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Connection_Interface_Addressing.xml -i org.freedesktop.Telepathy -o src/telepathy/connection_interface_addressing.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ConnectionInterfaceAddressing1 { + fn get_contacts_by_vcard_field( + &self, + field: &str, + addresses: Vec<&str>, + interfaces: Vec<&str>, + ) -> Result< + ( + ::std::collections::HashMap, + ::std::collections::HashMap< + u32, + ::std::collections::HashMap>>, + >, + ), + tree::MethodErr, + >; + fn get_contacts_by_uri( + &self, + uris: Vec<&str>, + interfaces: Vec<&str>, + ) -> Result< + ( + ::std::collections::HashMap, + ::std::collections::HashMap< + u32, + ::std::collections::HashMap>>, + >, + ), + tree::MethodErr, + >; +} + +pub fn connection_interface_addressing1_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + T: ConnectionInterfaceAddressing1, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface( + "org.freedesktop.Telepathy.Connection.Interface.Addressing1", + data, + ); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let field: &str = i.read()?; + let addresses: Vec<&str> = i.read()?; + let interfaces: Vec<&str> = i.read()?; + let d = fclone(minfo); + let (requested, attributes) = + d.get_contacts_by_vcard_field(field, addresses, interfaces)?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(requested); + let rm = rm.append1(attributes); + Ok(vec![rm]) + }; + let m = factory.method("GetContactsByVCardField", Default::default(), h); + let m = m.in_arg(("Field", "s")); + let m = m.in_arg(("Addresses", "as")); + let m = m.in_arg(("Interfaces", "as")); + let m = m.out_arg(("Requested", "a{su}")); + let m = m.out_arg(("Attributes", "a{ua{sv}}")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let uris: Vec<&str> = i.read()?; + let interfaces: Vec<&str> = i.read()?; + let d = fclone(minfo); + let (requested, attributes) = d.get_contacts_by_uri(uris, interfaces)?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(requested); + let rm = rm.append1(attributes); + Ok(vec![rm]) + }; + let m = factory.method("GetContactsByURI", Default::default(), h); + let m = m.in_arg(("URIs", "as")); + let m = m.in_arg(("Interfaces", "as")); + let m = m.out_arg(("Requested", "a{su}")); + let m = m.out_arg(("Attributes", "a{ua{sv}}")); + let i = i.add_m(m); + i +} diff --git a/src/telepathy/connection_interface_aliasing.rs b/src/telepathy/connection_interface_aliasing.rs new file mode 100644 index 0000000..e13db83 --- /dev/null +++ b/src/telepathy/connection_interface_aliasing.rs @@ -0,0 +1,116 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Connection_Interface_Aliasing.xml -i org.freedesktop.Telepathy -o src/telepathy/connection_interface_aliasing.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ConnectionInterfaceAliasing { + fn get_alias_flags(&self) -> Result; + fn request_aliases(&self, contacts: Vec) -> Result, tree::MethodErr>; + fn get_aliases( + &self, + contacts: Vec, + ) -> Result<::std::collections::HashMap, tree::MethodErr>; + fn set_aliases( + &self, + aliases: ::std::collections::HashMap, + ) -> Result<(), tree::MethodErr>; +} + +pub fn connection_interface_aliasing_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Signal: Default, + T: ConnectionInterfaceAliasing, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface( + "org.freedesktop.Telepathy.Connection.Interface.Aliasing", + data, + ); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let d = fclone(minfo); + let alias_flags = d.get_alias_flags()?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(alias_flags); + Ok(vec![rm]) + }; + let m = factory.method("GetAliasFlags", Default::default(), h); + let m = m.out_arg(("Alias_Flags", "u")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let contacts: Vec = i.read()?; + let d = fclone(minfo); + let aliases = d.request_aliases(contacts)?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(aliases); + Ok(vec![rm]) + }; + let m = factory.method("RequestAliases", Default::default(), h); + let m = m.in_arg(("Contacts", "au")); + let m = m.out_arg(("Aliases", "as")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let contacts: Vec = i.read()?; + let d = fclone(minfo); + let aliases = d.get_aliases(contacts)?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(aliases); + Ok(vec![rm]) + }; + let m = factory.method("GetAliases", Default::default(), h); + let m = m.in_arg(("Contacts", "au")); + let m = m.out_arg(("Aliases", "a{us}")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let aliases: ::std::collections::HashMap = i.read()?; + let d = fclone(minfo); + d.set_aliases(aliases)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("SetAliases", Default::default(), h); + let m = m.in_arg(("Aliases", "a{us}")); + let i = i.add_m(m); + let s = factory.signal("AliasesChanged", Default::default()); + let s = s.arg(("Aliases", "a(us)")); + let i = i.add_s(s); + i +} + +#[derive(Debug)] +pub struct ConnectionInterfaceAliasingAliasesChanged { + pub aliases: Vec<(u32, String)>, +} + +impl arg::AppendAll for ConnectionInterfaceAliasingAliasesChanged { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.aliases, i); + } +} + +impl arg::ReadAll for ConnectionInterfaceAliasingAliasesChanged { + fn read(i: &mut arg::Iter) -> Result { + Ok(ConnectionInterfaceAliasingAliasesChanged { aliases: i.read()? }) + } +} + +impl dbus::message::SignalArgs for ConnectionInterfaceAliasingAliasesChanged { + const NAME: &'static str = "AliasesChanged"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Connection.Interface.Aliasing"; +} diff --git a/src/telepathy/connection_interface_anonymity.rs b/src/telepathy/connection_interface_anonymity.rs new file mode 100644 index 0000000..bddd0e4 --- /dev/null +++ b/src/telepathy/connection_interface_anonymity.rs @@ -0,0 +1,104 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Connection_Interface_Anonymity.xml -i org.freedesktop.Telepathy -o src/telepathy/connection_interface_anonymity.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ConnectionInterfaceAnonymity { + fn supported_anonymity_modes(&self) -> Result; + fn anonymity_mandatory(&self) -> Result; + fn set_anonymity_mandatory(&self, value: bool) -> Result<(), tree::MethodErr>; + fn anonymity_modes(&self) -> Result; + fn set_anonymity_modes(&self, value: u32) -> Result<(), tree::MethodErr>; +} + +pub fn connection_interface_anonymity_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + D::Signal: Default, + T: ConnectionInterfaceAnonymity, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface( + "org.freedesktop.Telepathy.Connection.Interface.Anonymity", + data, + ); + let f = ::std::sync::Arc::new(f); + let p = factory.property::("SupportedAnonymityModes", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.supported_anonymity_modes()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("AnonymityMandatory", Default::default()); + let p = p.access(tree::Access::ReadWrite); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.anonymity_mandatory()?); + Ok(()) + }); + let fclone = f.clone(); + let p = p.on_set(move |iter, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + d.set_anonymity_mandatory(iter.read()?)?; + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("AnonymityModes", Default::default()); + let p = p.access(tree::Access::ReadWrite); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.anonymity_modes()?); + Ok(()) + }); + let fclone = f.clone(); + let p = p.on_set(move |iter, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + d.set_anonymity_modes(iter.read()?)?; + Ok(()) + }); + let i = i.add_p(p); + let s = factory.signal("AnonymityModesChanged", Default::default()); + let s = s.arg(("Modes", "u")); + let i = i.add_s(s); + i +} + +#[derive(Debug)] +pub struct ConnectionInterfaceAnonymityAnonymityModesChanged { + pub modes: u32, +} + +impl arg::AppendAll for ConnectionInterfaceAnonymityAnonymityModesChanged { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.modes, i); + } +} + +impl arg::ReadAll for ConnectionInterfaceAnonymityAnonymityModesChanged { + fn read(i: &mut arg::Iter) -> Result { + Ok(ConnectionInterfaceAnonymityAnonymityModesChanged { modes: i.read()? }) + } +} + +impl dbus::message::SignalArgs for ConnectionInterfaceAnonymityAnonymityModesChanged { + const NAME: &'static str = "AnonymityModesChanged"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Connection.Interface.Anonymity"; +} diff --git a/src/telepathy/connection_interface_avatars.rs b/src/telepathy/connection_interface_avatars.rs new file mode 100644 index 0000000..daf82a2 --- /dev/null +++ b/src/telepathy/connection_interface_avatars.rs @@ -0,0 +1,315 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Connection_Interface_Avatars.xml -i org.freedesktop.Telepathy -o src/telepathy/connection_interface_avatars.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ConnectionInterfaceAvatars { + fn get_avatar_requirements( + &self, + ) -> Result<(Vec, u16, u16, u16, u16, u32), tree::MethodErr>; + fn get_avatar_tokens(&self, contacts: Vec) -> Result, tree::MethodErr>; + fn get_known_avatar_tokens( + &self, + contacts: Vec, + ) -> Result<::std::collections::HashMap, tree::MethodErr>; + fn request_avatar(&self, contact: u32) -> Result<(Vec, String), tree::MethodErr>; + fn request_avatars(&self, contacts: Vec) -> Result<(), tree::MethodErr>; + fn set_avatar(&self, avatar: Vec, mimetype: &str) -> Result; + fn clear_avatar(&self) -> Result<(), tree::MethodErr>; + fn supported_avatar_mimetypes(&self) -> Result, tree::MethodErr>; + fn minimum_avatar_height(&self) -> Result; + fn minimum_avatar_width(&self) -> Result; + fn recommended_avatar_height(&self) -> Result; + fn recommended_avatar_width(&self) -> Result; + fn maximum_avatar_height(&self) -> Result; + fn maximum_avatar_width(&self) -> Result; + fn maximum_avatar_bytes(&self) -> Result; +} + +pub fn connection_interface_avatars_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + D::Signal: Default, + T: ConnectionInterfaceAvatars, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface( + "org.freedesktop.Telepathy.Connection.Interface.Avatars", + data, + ); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let d = fclone(minfo); + let (mimetypes, min_width, min_height, max_width, max_height, max_bytes) = + d.get_avatar_requirements()?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(mimetypes); + let rm = rm.append1(min_width); + let rm = rm.append1(min_height); + let rm = rm.append1(max_width); + let rm = rm.append1(max_height); + let rm = rm.append1(max_bytes); + Ok(vec![rm]) + }; + let m = factory.method("GetAvatarRequirements", Default::default(), h); + let m = m.out_arg(("MIME_Types", "as")); + let m = m.out_arg(("Min_Width", "q")); + let m = m.out_arg(("Min_Height", "q")); + let m = m.out_arg(("Max_Width", "q")); + let m = m.out_arg(("Max_Height", "q")); + let m = m.out_arg(("Max_Bytes", "u")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let contacts: Vec = i.read()?; + let d = fclone(minfo); + let tokens = d.get_avatar_tokens(contacts)?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(tokens); + Ok(vec![rm]) + }; + let m = factory.method("GetAvatarTokens", Default::default(), h); + let m = m.in_arg(("Contacts", "au")); + let m = m.out_arg(("Tokens", "as")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let contacts: Vec = i.read()?; + let d = fclone(minfo); + let tokens = d.get_known_avatar_tokens(contacts)?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(tokens); + Ok(vec![rm]) + }; + let m = factory.method("GetKnownAvatarTokens", Default::default(), h); + let m = m.in_arg(("Contacts", "au")); + let m = m.out_arg(("Tokens", "a{us}")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let contact: u32 = i.read()?; + let d = fclone(minfo); + let (data, mimetype) = d.request_avatar(contact)?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(data); + let rm = rm.append1(mimetype); + Ok(vec![rm]) + }; + let m = factory.method("RequestAvatar", Default::default(), h); + let m = m.in_arg(("Contact", "u")); + let m = m.out_arg(("Data", "ay")); + let m = m.out_arg(("MIME_Type", "s")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let contacts: Vec = i.read()?; + let d = fclone(minfo); + d.request_avatars(contacts)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("RequestAvatars", Default::default(), h); + let m = m.in_arg(("Contacts", "au")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let avatar: Vec = i.read()?; + let mimetype: &str = i.read()?; + let d = fclone(minfo); + let token = d.set_avatar(avatar, mimetype)?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(token); + Ok(vec![rm]) + }; + let m = factory.method("SetAvatar", Default::default(), h); + let m = m.in_arg(("Avatar", "ay")); + let m = m.in_arg(("MIME_Type", "s")); + let m = m.out_arg(("Token", "s")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let d = fclone(minfo); + d.clear_avatar()?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("ClearAvatar", Default::default(), h); + let i = i.add_m(m); + + let p = factory.property::, _>("SupportedAvatarMIMETypes", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.supported_avatar_mimetypes()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("MinimumAvatarHeight", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.minimum_avatar_height()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("MinimumAvatarWidth", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.minimum_avatar_width()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("RecommendedAvatarHeight", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.recommended_avatar_height()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("RecommendedAvatarWidth", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.recommended_avatar_width()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("MaximumAvatarHeight", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.maximum_avatar_height()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("MaximumAvatarWidth", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.maximum_avatar_width()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("MaximumAvatarBytes", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.maximum_avatar_bytes()?); + Ok(()) + }); + let i = i.add_p(p); + let s = factory.signal("AvatarUpdated", Default::default()); + let s = s.arg(("Contact", "u")); + let s = s.arg(("New_Avatar_Token", "s")); + let i = i.add_s(s); + let s = factory.signal("AvatarRetrieved", Default::default()); + let s = s.arg(("Contact", "u")); + let s = s.arg(("Token", "s")); + let s = s.arg(("Avatar", "ay")); + let s = s.arg(("Type", "s")); + let i = i.add_s(s); + i +} + +#[derive(Debug)] +pub struct ConnectionInterfaceAvatarsAvatarUpdated { + pub contact: u32, + pub new_avatar_token: String, +} + +impl arg::AppendAll for ConnectionInterfaceAvatarsAvatarUpdated { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.contact, i); + arg::RefArg::append(&self.new_avatar_token, i); + } +} + +impl arg::ReadAll for ConnectionInterfaceAvatarsAvatarUpdated { + fn read(i: &mut arg::Iter) -> Result { + Ok(ConnectionInterfaceAvatarsAvatarUpdated { + contact: i.read()?, + new_avatar_token: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for ConnectionInterfaceAvatarsAvatarUpdated { + const NAME: &'static str = "AvatarUpdated"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Connection.Interface.Avatars"; +} + +#[derive(Debug)] +pub struct ConnectionInterfaceAvatarsAvatarRetrieved { + pub contact: u32, + pub token: String, + pub avatar: Vec, + pub type_: String, +} + +impl arg::AppendAll for ConnectionInterfaceAvatarsAvatarRetrieved { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.contact, i); + arg::RefArg::append(&self.token, i); + arg::RefArg::append(&self.avatar, i); + arg::RefArg::append(&self.type_, i); + } +} + +impl arg::ReadAll for ConnectionInterfaceAvatarsAvatarRetrieved { + fn read(i: &mut arg::Iter) -> Result { + Ok(ConnectionInterfaceAvatarsAvatarRetrieved { + contact: i.read()?, + token: i.read()?, + avatar: i.read()?, + type_: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for ConnectionInterfaceAvatarsAvatarRetrieved { + const NAME: &'static str = "AvatarRetrieved"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Connection.Interface.Avatars"; +} diff --git a/src/telepathy/connection_interface_balance.rs b/src/telepathy/connection_interface_balance.rs new file mode 100644 index 0000000..cb17e09 --- /dev/null +++ b/src/telepathy/connection_interface_balance.rs @@ -0,0 +1,76 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Connection_Interface_Balance.xml -i org.freedesktop.Telepathy -o src/telepathy/connection_interface_balance.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ConnectionInterfaceBalance { + fn account_balance(&self) -> Result<(i32, u32, String), tree::MethodErr>; + fn manage_credit_uri(&self) -> Result; +} + +pub fn connection_interface_balance_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + D::Signal: Default, + T: ConnectionInterfaceBalance, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface( + "org.freedesktop.Telepathy.Connection.Interface.Balance", + data, + ); + let f = ::std::sync::Arc::new(f); + let p = factory.property::<(i32, u32, &str), _>("AccountBalance", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.account_balance()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::<&str, _>("ManageCreditURI", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.manage_credit_uri()?); + Ok(()) + }); + let i = i.add_p(p); + let s = factory.signal("BalanceChanged", Default::default()); + let s = s.arg(("Balance", "(ius)")); + let i = i.add_s(s); + i +} + +#[derive(Debug)] +pub struct ConnectionInterfaceBalanceBalanceChanged { + pub balance: (i32, u32, String), +} + +impl arg::AppendAll for ConnectionInterfaceBalanceBalanceChanged { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.balance, i); + } +} + +impl arg::ReadAll for ConnectionInterfaceBalanceBalanceChanged { + fn read(i: &mut arg::Iter) -> Result { + Ok(ConnectionInterfaceBalanceBalanceChanged { balance: i.read()? }) + } +} + +impl dbus::message::SignalArgs for ConnectionInterfaceBalanceBalanceChanged { + const NAME: &'static str = "BalanceChanged"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Connection.Interface.Balance"; +} diff --git a/src/telepathy/connection_interface_capabilities.rs b/src/telepathy/connection_interface_capabilities.rs new file mode 100644 index 0000000..0c48bbc --- /dev/null +++ b/src/telepathy/connection_interface_capabilities.rs @@ -0,0 +1,92 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Connection_Interface_Capabilities.xml -i org.freedesktop.Telepathy -o src/telepathy/connection_interface_capabilities.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ConnectionInterfaceCapabilities { + fn advertise_capabilities( + &self, + add: Vec<(&str, u32)>, + remove: Vec<&str>, + ) -> Result, tree::MethodErr>; + fn get_capabilities( + &self, + handles: Vec, + ) -> Result, tree::MethodErr>; +} + +pub fn connection_interface_capabilities_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Signal: Default, + T: ConnectionInterfaceCapabilities, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface( + "org.freedesktop.Telepathy.Connection.Interface.Capabilities", + data, + ); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let add: Vec<(&str, u32)> = i.read()?; + let remove: Vec<&str> = i.read()?; + let d = fclone(minfo); + let self_capabilities = d.advertise_capabilities(add, remove)?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(self_capabilities); + Ok(vec![rm]) + }; + let m = factory.method("AdvertiseCapabilities", Default::default(), h); + let m = m.in_arg(("Add", "a(su)")); + let m = m.in_arg(("Remove", "as")); + let m = m.out_arg(("Self_Capabilities", "a(su)")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let handles: Vec = i.read()?; + let d = fclone(minfo); + let contact_capabilities = d.get_capabilities(handles)?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(contact_capabilities); + Ok(vec![rm]) + }; + let m = factory.method("GetCapabilities", Default::default(), h); + let m = m.in_arg(("Handles", "au")); + let m = m.out_arg(("Contact_Capabilities", "a(usuu)")); + let i = i.add_m(m); + let s = factory.signal("CapabilitiesChanged", Default::default()); + let s = s.arg(("Caps", "a(usuuuu)")); + let i = i.add_s(s); + i +} + +#[derive(Debug)] +pub struct ConnectionInterfaceCapabilitiesCapabilitiesChanged { + pub caps: Vec<(u32, String, u32, u32, u32, u32)>, +} + +impl arg::AppendAll for ConnectionInterfaceCapabilitiesCapabilitiesChanged { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.caps, i); + } +} + +impl arg::ReadAll for ConnectionInterfaceCapabilitiesCapabilitiesChanged { + fn read(i: &mut arg::Iter) -> Result { + Ok(ConnectionInterfaceCapabilitiesCapabilitiesChanged { caps: i.read()? }) + } +} + +impl dbus::message::SignalArgs for ConnectionInterfaceCapabilitiesCapabilitiesChanged { + const NAME: &'static str = "CapabilitiesChanged"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Connection.Interface.Capabilities"; +} diff --git a/src/telepathy/connection_interface_cellular.rs b/src/telepathy/connection_interface_cellular.rs new file mode 100644 index 0000000..8cc3022 --- /dev/null +++ b/src/telepathy/connection_interface_cellular.rs @@ -0,0 +1,164 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Connection_Interface_Cellular.xml -i org.freedesktop.Telepathy -o src/telepathy/connection_interface_cellular.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ConnectionInterfaceCellular { + fn message_validity_period(&self) -> Result; + fn set_message_validity_period(&self, value: u32) -> Result<(), tree::MethodErr>; + fn override_message_service_centre(&self) -> Result; + fn set_override_message_service_centre(&self, value: bool) -> Result<(), tree::MethodErr>; + fn message_service_centre(&self) -> Result; + fn set_message_service_centre(&self, value: String) -> Result<(), tree::MethodErr>; + fn imsi(&self) -> Result; + fn message_reduced_character_set(&self) -> Result; + fn set_message_reduced_character_set(&self, value: bool) -> Result<(), tree::MethodErr>; + fn message_national_character_set(&self) -> Result; + fn set_message_national_character_set(&self, value: String) -> Result<(), tree::MethodErr>; +} + +pub fn connection_interface_cellular_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + D::Signal: Default, + T: ConnectionInterfaceCellular, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface( + "org.freedesktop.Telepathy.Connection.Interface.Cellular", + data, + ); + let f = ::std::sync::Arc::new(f); + let p = factory.property::("MessageValidityPeriod", Default::default()); + let p = p.access(tree::Access::ReadWrite); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.message_validity_period()?); + Ok(()) + }); + let fclone = f.clone(); + let p = p.on_set(move |iter, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + d.set_message_validity_period(iter.read()?)?; + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("OverrideMessageServiceCentre", Default::default()); + let p = p.access(tree::Access::ReadWrite); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.override_message_service_centre()?); + Ok(()) + }); + let fclone = f.clone(); + let p = p.on_set(move |iter, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + d.set_override_message_service_centre(iter.read()?)?; + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::<&str, _>("MessageServiceCentre", Default::default()); + let p = p.access(tree::Access::ReadWrite); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.message_service_centre()?); + Ok(()) + }); + let fclone = f.clone(); + let p = p.on_set(move |iter, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + d.set_message_service_centre(iter.read()?)?; + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::<&str, _>("IMSI", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.imsi()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("MessageReducedCharacterSet", Default::default()); + let p = p.access(tree::Access::ReadWrite); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.message_reduced_character_set()?); + Ok(()) + }); + let fclone = f.clone(); + let p = p.on_set(move |iter, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + d.set_message_reduced_character_set(iter.read()?)?; + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::<&str, _>("MessageNationalCharacterSet", Default::default()); + let p = p.access(tree::Access::ReadWrite); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.message_national_character_set()?); + Ok(()) + }); + let fclone = f.clone(); + let p = p.on_set(move |iter, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + d.set_message_national_character_set(iter.read()?)?; + Ok(()) + }); + let i = i.add_p(p); + let s = factory.signal("IMSIChanged", Default::default()); + let s = s.arg(("IMSI", "s")); + let i = i.add_s(s); + i +} + +#[derive(Debug)] +pub struct ConnectionInterfaceCellularIMSIChanged { + pub imsi: String, +} + +impl arg::AppendAll for ConnectionInterfaceCellularIMSIChanged { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.imsi, i); + } +} + +impl arg::ReadAll for ConnectionInterfaceCellularIMSIChanged { + fn read(i: &mut arg::Iter) -> Result { + Ok(ConnectionInterfaceCellularIMSIChanged { imsi: i.read()? }) + } +} + +impl dbus::message::SignalArgs for ConnectionInterfaceCellularIMSIChanged { + const NAME: &'static str = "IMSIChanged"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Connection.Interface.Cellular"; +} diff --git a/src/telepathy/connection_interface_client_types.rs b/src/telepathy/connection_interface_client_types.rs new file mode 100644 index 0000000..783f70d --- /dev/null +++ b/src/telepathy/connection_interface_client_types.rs @@ -0,0 +1,92 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Connection_Interface_Client_Types.xml -i org.freedesktop.Telepathy -o src/telepathy/connection_interface_client_types.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ConnectionInterfaceClientTypes { + fn get_client_types( + &self, + contacts: Vec, + ) -> Result<::std::collections::HashMap>, tree::MethodErr>; + fn request_client_types(&self, contact: u32) -> Result, tree::MethodErr>; +} + +pub fn connection_interface_client_types_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Signal: Default, + T: ConnectionInterfaceClientTypes, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface( + "org.freedesktop.Telepathy.Connection.Interface.ClientTypes", + data, + ); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let contacts: Vec = i.read()?; + let d = fclone(minfo); + let client_types = d.get_client_types(contacts)?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(client_types); + Ok(vec![rm]) + }; + let m = factory.method("GetClientTypes", Default::default(), h); + let m = m.in_arg(("Contacts", "au")); + let m = m.out_arg(("Client_Types", "a{uas}")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let contact: u32 = i.read()?; + let d = fclone(minfo); + let client_types = d.request_client_types(contact)?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(client_types); + Ok(vec![rm]) + }; + let m = factory.method("RequestClientTypes", Default::default(), h); + let m = m.in_arg(("Contact", "u")); + let m = m.out_arg(("Client_Types", "as")); + let i = i.add_m(m); + let s = factory.signal("ClientTypesUpdated", Default::default()); + let s = s.arg(("Contact", "u")); + let s = s.arg(("Client_Types", "as")); + let i = i.add_s(s); + i +} + +#[derive(Debug)] +pub struct ConnectionInterfaceClientTypesClientTypesUpdated { + pub contact: u32, + pub client_types: Vec, +} + +impl arg::AppendAll for ConnectionInterfaceClientTypesClientTypesUpdated { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.contact, i); + arg::RefArg::append(&self.client_types, i); + } +} + +impl arg::ReadAll for ConnectionInterfaceClientTypesClientTypesUpdated { + fn read(i: &mut arg::Iter) -> Result { + Ok(ConnectionInterfaceClientTypesClientTypesUpdated { + contact: i.read()?, + client_types: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for ConnectionInterfaceClientTypesClientTypesUpdated { + const NAME: &'static str = "ClientTypesUpdated"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Connection.Interface.ClientTypes"; +} diff --git a/src/telepathy/connection_interface_communication_policy.rs b/src/telepathy/connection_interface_communication_policy.rs new file mode 100644 index 0000000..3311c3b --- /dev/null +++ b/src/telepathy/connection_interface_communication_policy.rs @@ -0,0 +1,106 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Connection_Interface_Communication_Policy.xml -i org.freedesktop.Telepathy -o src/telepathy/connection_interface_communication_policy.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ConnectionInterfaceCommunicationPolicyDRAFT { + fn set_policy( + &self, + channel_type: &str, + policy: (u32, arg::Variant>), + ) -> Result<(), tree::MethodErr>; + fn supported_policies(&self) -> Result, Vec)>, tree::MethodErr>; + fn active_policies( + &self, + ) -> Result< + ::std::collections::HashMap>)>, + tree::MethodErr, + >; +} + +pub fn connection_interface_communication_policy_draft_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + D::Signal: Default, + T: ConnectionInterfaceCommunicationPolicyDRAFT, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface( + "org.freedesktop.Telepathy.Connection.Interface.CommunicationPolicy.DRAFT", + data, + ); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let channel_type: &str = i.read()?; + let policy: (u32, arg::Variant>) = i.read()?; + let d = fclone(minfo); + d.set_policy(channel_type, policy)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("SetPolicy", Default::default(), h); + let m = m.in_arg(("Channel_Type", "s")); + let m = m.in_arg(("Policy", "(uv)")); + let i = i.add_m(m); + + let p = + factory.property::, Vec)>, _>("SupportedPolicies", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.supported_policies()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::<::std::collections::HashMap<&str, (u32, arg::Variant>)>, _>("ActivePolicies", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.active_policies()?); + Ok(()) + }); + let i = i.add_p(p); + let s = factory.signal("PolicyChanged", Default::default()); + let s = s.arg(("Changed_Policies", "a{s(uv)}")); + let i = i.add_s(s); + i +} + +#[derive(Debug)] +pub struct ConnectionInterfaceCommunicationPolicyDRAFTPolicyChanged { + pub changed_policies: + ::std::collections::HashMap>)>, +} + +impl arg::AppendAll for ConnectionInterfaceCommunicationPolicyDRAFTPolicyChanged { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.changed_policies, i); + } +} + +impl arg::ReadAll for ConnectionInterfaceCommunicationPolicyDRAFTPolicyChanged { + fn read(i: &mut arg::Iter) -> Result { + Ok(ConnectionInterfaceCommunicationPolicyDRAFTPolicyChanged { + changed_policies: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for ConnectionInterfaceCommunicationPolicyDRAFTPolicyChanged { + const NAME: &'static str = "PolicyChanged"; + const INTERFACE: &'static str = + "org.freedesktop.Telepathy.Connection.Interface.CommunicationPolicy.DRAFT"; +} diff --git a/src/telepathy/connection_interface_contact_blocking.rs b/src/telepathy/connection_interface_contact_blocking.rs new file mode 100644 index 0000000..75df027 --- /dev/null +++ b/src/telepathy/connection_interface_contact_blocking.rs @@ -0,0 +1,120 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Connection_Interface_Contact_Blocking.xml -i org.freedesktop.Telepathy -o src/telepathy/connection_interface_contact_blocking.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ConnectionInterfaceContactBlocking { + fn block_contacts( + &self, + contacts: Vec, + report_abusive: bool, + ) -> Result<(), tree::MethodErr>; + fn unblock_contacts(&self, contacts: Vec) -> Result<(), tree::MethodErr>; + fn request_blocked_contacts( + &self, + ) -> Result<::std::collections::HashMap, tree::MethodErr>; + fn contact_blocking_capabilities(&self) -> Result; +} + +pub fn connection_interface_contact_blocking_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + D::Signal: Default, + T: ConnectionInterfaceContactBlocking, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface( + "org.freedesktop.Telepathy.Connection.Interface.ContactBlocking", + data, + ); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let contacts: Vec = i.read()?; + let report_abusive: bool = i.read()?; + let d = fclone(minfo); + d.block_contacts(contacts, report_abusive)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("BlockContacts", Default::default(), h); + let m = m.in_arg(("Contacts", "au")); + let m = m.in_arg(("Report_Abusive", "b")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let contacts: Vec = i.read()?; + let d = fclone(minfo); + d.unblock_contacts(contacts)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("UnblockContacts", Default::default(), h); + let m = m.in_arg(("Contacts", "au")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let d = fclone(minfo); + let contacts = d.request_blocked_contacts()?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(contacts); + Ok(vec![rm]) + }; + let m = factory.method("RequestBlockedContacts", Default::default(), h); + let m = m.out_arg(("Contacts", "a{us}")); + let i = i.add_m(m); + + let p = factory.property::("ContactBlockingCapabilities", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.contact_blocking_capabilities()?); + Ok(()) + }); + let i = i.add_p(p); + let s = factory.signal("BlockedContactsChanged", Default::default()); + let s = s.arg(("Blocked_Contacts", "a{us}")); + let s = s.arg(("Unblocked_Contacts", "a{us}")); + let i = i.add_s(s); + i +} + +#[derive(Debug)] +pub struct ConnectionInterfaceContactBlockingBlockedContactsChanged { + pub blocked_contacts: ::std::collections::HashMap, + pub unblocked_contacts: ::std::collections::HashMap, +} + +impl arg::AppendAll for ConnectionInterfaceContactBlockingBlockedContactsChanged { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.blocked_contacts, i); + arg::RefArg::append(&self.unblocked_contacts, i); + } +} + +impl arg::ReadAll for ConnectionInterfaceContactBlockingBlockedContactsChanged { + fn read(i: &mut arg::Iter) -> Result { + Ok(ConnectionInterfaceContactBlockingBlockedContactsChanged { + blocked_contacts: i.read()?, + unblocked_contacts: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for ConnectionInterfaceContactBlockingBlockedContactsChanged { + const NAME: &'static str = "BlockedContactsChanged"; + const INTERFACE: &'static str = + "org.freedesktop.Telepathy.Connection.Interface.ContactBlocking"; +} diff --git a/src/telepathy/connection_interface_contact_capabilities.rs b/src/telepathy/connection_interface_contact_capabilities.rs new file mode 100644 index 0000000..d38b378 --- /dev/null +++ b/src/telepathy/connection_interface_contact_capabilities.rs @@ -0,0 +1,113 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Connection_Interface_Contact_Capabilities.xml -i org.freedesktop.Telepathy -o src/telepathy/connection_interface_contact_capabilities.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ConnectionInterfaceContactCapabilities { + fn update_capabilities( + &self, + handler_capabilities: Vec<( + &str, + Vec<::std::collections::HashMap<&str, arg::Variant>>>, + Vec<&str>, + )>, + ) -> Result<(), tree::MethodErr>; + fn get_contact_capabilities( + &self, + handles: Vec, + ) -> Result< + ::std::collections::HashMap< + u32, + Vec<( + ::std::collections::HashMap>>, + Vec, + )>, + >, + tree::MethodErr, + >; +} + +pub fn connection_interface_contact_capabilities_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Signal: Default, + T: ConnectionInterfaceContactCapabilities, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface( + "org.freedesktop.Telepathy.Connection.Interface.ContactCapabilities", + data, + ); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let handler_capabilities: Vec<( + &str, + Vec<::std::collections::HashMap<&str, arg::Variant>>>, + Vec<&str>, + )> = i.read()?; + let d = fclone(minfo); + d.update_capabilities(handler_capabilities)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("UpdateCapabilities", Default::default(), h); + let m = m.in_arg(("Handler_Capabilities", "a(saa{sv}as)")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let handles: Vec = i.read()?; + let d = fclone(minfo); + let contact_capabilities = d.get_contact_capabilities(handles)?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(contact_capabilities); + Ok(vec![rm]) + }; + let m = factory.method("GetContactCapabilities", Default::default(), h); + let m = m.in_arg(("Handles", "au")); + let m = m.out_arg(("Contact_Capabilities", "a{ua(a{sv}as)}")); + let i = i.add_m(m); + let s = factory.signal("ContactCapabilitiesChanged", Default::default()); + let s = s.arg(("caps", "a{ua(a{sv}as)}")); + let i = i.add_s(s); + i +} + +#[derive(Debug)] +pub struct ConnectionInterfaceContactCapabilitiesContactCapabilitiesChanged { + pub caps: ::std::collections::HashMap< + u32, + Vec<( + ::std::collections::HashMap>>, + Vec, + )>, + >, +} + +impl arg::AppendAll for ConnectionInterfaceContactCapabilitiesContactCapabilitiesChanged { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.caps, i); + } +} + +impl arg::ReadAll for ConnectionInterfaceContactCapabilitiesContactCapabilitiesChanged { + fn read(i: &mut arg::Iter) -> Result { + Ok(ConnectionInterfaceContactCapabilitiesContactCapabilitiesChanged { caps: i.read()? }) + } +} + +impl dbus::message::SignalArgs + for ConnectionInterfaceContactCapabilitiesContactCapabilitiesChanged +{ + const NAME: &'static str = "ContactCapabilitiesChanged"; + const INTERFACE: &'static str = + "org.freedesktop.Telepathy.Connection.Interface.ContactCapabilities"; +} diff --git a/src/telepathy/connection_interface_contact_groups.rs b/src/telepathy/connection_interface_contact_groups.rs new file mode 100644 index 0000000..ca3eaee --- /dev/null +++ b/src/telepathy/connection_interface_contact_groups.rs @@ -0,0 +1,273 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Connection_Interface_Contact_Groups.xml -i org.freedesktop.Telepathy -o src/telepathy/connection_interface_contact_groups.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ConnectionInterfaceContactGroups { + fn set_contact_groups(&self, contact: u32, groups: Vec<&str>) -> Result<(), tree::MethodErr>; + fn set_group_members(&self, group: &str, members: Vec) -> Result<(), tree::MethodErr>; + fn add_to_group(&self, group: &str, members: Vec) -> Result<(), tree::MethodErr>; + fn remove_from_group(&self, group: &str, members: Vec) -> Result<(), tree::MethodErr>; + fn remove_group(&self, group: &str) -> Result<(), tree::MethodErr>; + fn rename_group(&self, old_name: &str, new_name: &str) -> Result<(), tree::MethodErr>; + fn disjoint_groups(&self) -> Result; + fn group_storage(&self) -> Result; + fn groups(&self) -> Result, tree::MethodErr>; +} + +pub fn connection_interface_contact_groups_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + D::Signal: Default, + T: ConnectionInterfaceContactGroups, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface( + "org.freedesktop.Telepathy.Connection.Interface.ContactGroups", + data, + ); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let contact: u32 = i.read()?; + let groups: Vec<&str> = i.read()?; + let d = fclone(minfo); + d.set_contact_groups(contact, groups)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("SetContactGroups", Default::default(), h); + let m = m.in_arg(("Contact", "u")); + let m = m.in_arg(("Groups", "as")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let group: &str = i.read()?; + let members: Vec = i.read()?; + let d = fclone(minfo); + d.set_group_members(group, members)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("SetGroupMembers", Default::default(), h); + let m = m.in_arg(("Group", "s")); + let m = m.in_arg(("Members", "au")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let group: &str = i.read()?; + let members: Vec = i.read()?; + let d = fclone(minfo); + d.add_to_group(group, members)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("AddToGroup", Default::default(), h); + let m = m.in_arg(("Group", "s")); + let m = m.in_arg(("Members", "au")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let group: &str = i.read()?; + let members: Vec = i.read()?; + let d = fclone(minfo); + d.remove_from_group(group, members)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("RemoveFromGroup", Default::default(), h); + let m = m.in_arg(("Group", "s")); + let m = m.in_arg(("Members", "au")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let group: &str = i.read()?; + let d = fclone(minfo); + d.remove_group(group)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("RemoveGroup", Default::default(), h); + let m = m.in_arg(("Group", "s")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let old_name: &str = i.read()?; + let new_name: &str = i.read()?; + let d = fclone(minfo); + d.rename_group(old_name, new_name)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("RenameGroup", Default::default(), h); + let m = m.in_arg(("Old_Name", "s")); + let m = m.in_arg(("New_Name", "s")); + let i = i.add_m(m); + + let p = factory.property::("DisjointGroups", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.disjoint_groups()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("GroupStorage", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.group_storage()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::, _>("Groups", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.groups()?); + Ok(()) + }); + let i = i.add_p(p); + let s = factory.signal("GroupsChanged", Default::default()); + let s = s.arg(("Contact", "au")); + let s = s.arg(("Added", "as")); + let s = s.arg(("Removed", "as")); + let i = i.add_s(s); + let s = factory.signal("GroupsCreated", Default::default()); + let s = s.arg(("Names", "as")); + let i = i.add_s(s); + let s = factory.signal("GroupRenamed", Default::default()); + let s = s.arg(("Old_Name", "s")); + let s = s.arg(("New_Name", "s")); + let i = i.add_s(s); + let s = factory.signal("GroupsRemoved", Default::default()); + let s = s.arg(("Names", "as")); + let i = i.add_s(s); + i +} + +#[derive(Debug)] +pub struct ConnectionInterfaceContactGroupsGroupsChanged { + pub contact: Vec, + pub added: Vec, + pub removed: Vec, +} + +impl arg::AppendAll for ConnectionInterfaceContactGroupsGroupsChanged { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.contact, i); + arg::RefArg::append(&self.added, i); + arg::RefArg::append(&self.removed, i); + } +} + +impl arg::ReadAll for ConnectionInterfaceContactGroupsGroupsChanged { + fn read(i: &mut arg::Iter) -> Result { + Ok(ConnectionInterfaceContactGroupsGroupsChanged { + contact: i.read()?, + added: i.read()?, + removed: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for ConnectionInterfaceContactGroupsGroupsChanged { + const NAME: &'static str = "GroupsChanged"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Connection.Interface.ContactGroups"; +} + +#[derive(Debug)] +pub struct ConnectionInterfaceContactGroupsGroupsCreated { + pub names: Vec, +} + +impl arg::AppendAll for ConnectionInterfaceContactGroupsGroupsCreated { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.names, i); + } +} + +impl arg::ReadAll for ConnectionInterfaceContactGroupsGroupsCreated { + fn read(i: &mut arg::Iter) -> Result { + Ok(ConnectionInterfaceContactGroupsGroupsCreated { names: i.read()? }) + } +} + +impl dbus::message::SignalArgs for ConnectionInterfaceContactGroupsGroupsCreated { + const NAME: &'static str = "GroupsCreated"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Connection.Interface.ContactGroups"; +} + +#[derive(Debug)] +pub struct ConnectionInterfaceContactGroupsGroupRenamed { + pub old_name: String, + pub new_name: String, +} + +impl arg::AppendAll for ConnectionInterfaceContactGroupsGroupRenamed { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.old_name, i); + arg::RefArg::append(&self.new_name, i); + } +} + +impl arg::ReadAll for ConnectionInterfaceContactGroupsGroupRenamed { + fn read(i: &mut arg::Iter) -> Result { + Ok(ConnectionInterfaceContactGroupsGroupRenamed { + old_name: i.read()?, + new_name: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for ConnectionInterfaceContactGroupsGroupRenamed { + const NAME: &'static str = "GroupRenamed"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Connection.Interface.ContactGroups"; +} + +#[derive(Debug)] +pub struct ConnectionInterfaceContactGroupsGroupsRemoved { + pub names: Vec, +} + +impl arg::AppendAll for ConnectionInterfaceContactGroupsGroupsRemoved { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.names, i); + } +} + +impl arg::ReadAll for ConnectionInterfaceContactGroupsGroupsRemoved { + fn read(i: &mut arg::Iter) -> Result { + Ok(ConnectionInterfaceContactGroupsGroupsRemoved { names: i.read()? }) + } +} + +impl dbus::message::SignalArgs for ConnectionInterfaceContactGroupsGroupsRemoved { + const NAME: &'static str = "GroupsRemoved"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Connection.Interface.ContactGroups"; +} diff --git a/src/telepathy/connection_interface_contact_info.rs b/src/telepathy/connection_interface_contact_info.rs new file mode 100644 index 0000000..7f382b3 --- /dev/null +++ b/src/telepathy/connection_interface_contact_info.rs @@ -0,0 +1,155 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Connection_Interface_Contact_Info.xml -i org.freedesktop.Telepathy -o src/telepathy/connection_interface_contact_info.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ConnectionInterfaceContactInfo { + fn get_contact_info( + &self, + contacts: Vec, + ) -> Result< + ::std::collections::HashMap, Vec)>>, + tree::MethodErr, + >; + fn refresh_contact_info(&self, contacts: Vec) -> Result<(), tree::MethodErr>; + fn request_contact_info( + &self, + contact: u32, + ) -> Result, Vec)>, tree::MethodErr>; + fn set_contact_info( + &self, + contact_info: Vec<(&str, Vec<&str>, Vec<&str>)>, + ) -> Result<(), tree::MethodErr>; + fn contact_info_flags(&self) -> Result; + fn supported_fields(&self) -> Result, u32, u32)>, tree::MethodErr>; +} + +pub fn connection_interface_contact_info_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + D::Signal: Default, + T: ConnectionInterfaceContactInfo, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface( + "org.freedesktop.Telepathy.Connection.Interface.ContactInfo", + data, + ); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let contacts: Vec = i.read()?; + let d = fclone(minfo); + let contact_info = d.get_contact_info(contacts)?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(contact_info); + Ok(vec![rm]) + }; + let m = factory.method("GetContactInfo", Default::default(), h); + let m = m.in_arg(("Contacts", "au")); + let m = m.out_arg(("ContactInfo", "a{ua(sasas)}")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let contacts: Vec = i.read()?; + let d = fclone(minfo); + d.refresh_contact_info(contacts)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("RefreshContactInfo", Default::default(), h); + let m = m.in_arg(("Contacts", "au")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let contact: u32 = i.read()?; + let d = fclone(minfo); + let contact_info = d.request_contact_info(contact)?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(contact_info); + Ok(vec![rm]) + }; + let m = factory.method("RequestContactInfo", Default::default(), h); + let m = m.in_arg(("Contact", "u")); + let m = m.out_arg(("Contact_Info", "a(sasas)")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let contact_info: Vec<(&str, Vec<&str>, Vec<&str>)> = i.read()?; + let d = fclone(minfo); + d.set_contact_info(contact_info)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("SetContactInfo", Default::default(), h); + let m = m.in_arg(("ContactInfo", "a(sasas)")); + let i = i.add_m(m); + + let p = factory.property::("ContactInfoFlags", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.contact_info_flags()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory + .property::, u32, u32)>, _>("SupportedFields", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.supported_fields()?); + Ok(()) + }); + let i = i.add_p(p); + let s = factory.signal("ContactInfoChanged", Default::default()); + let s = s.arg(("Contact", "u")); + let s = s.arg(("ContactInfo", "a(sasas)")); + let i = i.add_s(s); + i +} + +#[derive(Debug)] +pub struct ConnectionInterfaceContactInfoContactInfoChanged { + pub contact: u32, + pub contact_info: Vec<(String, Vec, Vec)>, +} + +impl arg::AppendAll for ConnectionInterfaceContactInfoContactInfoChanged { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.contact, i); + arg::RefArg::append(&self.contact_info, i); + } +} + +impl arg::ReadAll for ConnectionInterfaceContactInfoContactInfoChanged { + fn read(i: &mut arg::Iter) -> Result { + Ok(ConnectionInterfaceContactInfoContactInfoChanged { + contact: i.read()?, + contact_info: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for ConnectionInterfaceContactInfoContactInfoChanged { + const NAME: &'static str = "ContactInfoChanged"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Connection.Interface.ContactInfo"; +} diff --git a/src/telepathy/connection_interface_contact_list.rs b/src/telepathy/connection_interface_contact_list.rs new file mode 100644 index 0000000..1ed8d2a --- /dev/null +++ b/src/telepathy/connection_interface_contact_list.rs @@ -0,0 +1,295 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Connection_Interface_Contact_List.xml -i org.freedesktop.Telepathy -o src/telepathy/connection_interface_contact_list.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ConnectionInterfaceContactList { + fn get_contact_list_attributes( + &self, + interfaces: Vec<&str>, + hold: bool, + ) -> Result< + ::std::collections::HashMap< + u32, + ::std::collections::HashMap>>, + >, + tree::MethodErr, + >; + fn request_subscription( + &self, + contacts: Vec, + message: &str, + ) -> Result<(), tree::MethodErr>; + fn authorize_publication(&self, contacts: Vec) -> Result<(), tree::MethodErr>; + fn remove_contacts(&self, contacts: Vec) -> Result<(), tree::MethodErr>; + fn unsubscribe(&self, contacts: Vec) -> Result<(), tree::MethodErr>; + fn unpublish(&self, contacts: Vec) -> Result<(), tree::MethodErr>; + fn download(&self) -> Result<(), tree::MethodErr>; + fn contact_list_state(&self) -> Result; + fn contact_list_persists(&self) -> Result; + fn can_change_contact_list(&self) -> Result; + fn request_uses_message(&self) -> Result; + fn download_at_connection(&self) -> Result; +} + +pub fn connection_interface_contact_list_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + D::Signal: Default, + T: ConnectionInterfaceContactList, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface( + "org.freedesktop.Telepathy.Connection.Interface.ContactList", + data, + ); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let interfaces: Vec<&str> = i.read()?; + let hold: bool = i.read()?; + let d = fclone(minfo); + let attributes = d.get_contact_list_attributes(interfaces, hold)?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(attributes); + Ok(vec![rm]) + }; + let m = factory.method("GetContactListAttributes", Default::default(), h); + let m = m.in_arg(("Interfaces", "as")); + let m = m.in_arg(("Hold", "b")); + let m = m.out_arg(("Attributes", "a{ua{sv}}")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let contacts: Vec = i.read()?; + let message: &str = i.read()?; + let d = fclone(minfo); + d.request_subscription(contacts, message)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("RequestSubscription", Default::default(), h); + let m = m.in_arg(("Contacts", "au")); + let m = m.in_arg(("Message", "s")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let contacts: Vec = i.read()?; + let d = fclone(minfo); + d.authorize_publication(contacts)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("AuthorizePublication", Default::default(), h); + let m = m.in_arg(("Contacts", "au")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let contacts: Vec = i.read()?; + let d = fclone(minfo); + d.remove_contacts(contacts)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("RemoveContacts", Default::default(), h); + let m = m.in_arg(("Contacts", "au")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let contacts: Vec = i.read()?; + let d = fclone(minfo); + d.unsubscribe(contacts)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("Unsubscribe", Default::default(), h); + let m = m.in_arg(("Contacts", "au")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let contacts: Vec = i.read()?; + let d = fclone(minfo); + d.unpublish(contacts)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("Unpublish", Default::default(), h); + let m = m.in_arg(("Contacts", "au")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let d = fclone(minfo); + d.download()?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("Download", Default::default(), h); + let i = i.add_m(m); + + let p = factory.property::("ContactListState", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.contact_list_state()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("ContactListPersists", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.contact_list_persists()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("CanChangeContactList", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.can_change_contact_list()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("RequestUsesMessage", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.request_uses_message()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("DownloadAtConnection", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.download_at_connection()?); + Ok(()) + }); + let i = i.add_p(p); + let s = factory.signal("ContactListStateChanged", Default::default()); + let s = s.arg(("Contact_List_State", "u")); + let i = i.add_s(s); + let s = factory.signal("ContactsChangedWithID", Default::default()); + let s = s.arg(("Changes", "a{u(uus)}")); + let s = s.arg(("Identifiers", "a{us}")); + let s = s.arg(("Removals", "a{us}")); + let i = i.add_s(s); + let s = factory.signal("ContactsChanged", Default::default()); + let s = s.arg(("Changes", "a{u(uus)}")); + let s = s.arg(("Removals", "au")); + let i = i.add_s(s); + i +} + +#[derive(Debug)] +pub struct ConnectionInterfaceContactListContactListStateChanged { + pub contact_list_state: u32, +} + +impl arg::AppendAll for ConnectionInterfaceContactListContactListStateChanged { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.contact_list_state, i); + } +} + +impl arg::ReadAll for ConnectionInterfaceContactListContactListStateChanged { + fn read(i: &mut arg::Iter) -> Result { + Ok(ConnectionInterfaceContactListContactListStateChanged { + contact_list_state: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for ConnectionInterfaceContactListContactListStateChanged { + const NAME: &'static str = "ContactListStateChanged"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Connection.Interface.ContactList"; +} + +#[derive(Debug)] +pub struct ConnectionInterfaceContactListContactsChangedWithID { + pub changes: ::std::collections::HashMap, + pub identifiers: ::std::collections::HashMap, + pub removals: ::std::collections::HashMap, +} + +impl arg::AppendAll for ConnectionInterfaceContactListContactsChangedWithID { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.changes, i); + arg::RefArg::append(&self.identifiers, i); + arg::RefArg::append(&self.removals, i); + } +} + +impl arg::ReadAll for ConnectionInterfaceContactListContactsChangedWithID { + fn read(i: &mut arg::Iter) -> Result { + Ok(ConnectionInterfaceContactListContactsChangedWithID { + changes: i.read()?, + identifiers: i.read()?, + removals: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for ConnectionInterfaceContactListContactsChangedWithID { + const NAME: &'static str = "ContactsChangedWithID"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Connection.Interface.ContactList"; +} + +#[derive(Debug)] +pub struct ConnectionInterfaceContactListContactsChanged { + pub changes: ::std::collections::HashMap, + pub removals: Vec, +} + +impl arg::AppendAll for ConnectionInterfaceContactListContactsChanged { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.changes, i); + arg::RefArg::append(&self.removals, i); + } +} + +impl arg::ReadAll for ConnectionInterfaceContactListContactsChanged { + fn read(i: &mut arg::Iter) -> Result { + Ok(ConnectionInterfaceContactListContactsChanged { + changes: i.read()?, + removals: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for ConnectionInterfaceContactListContactsChanged { + const NAME: &'static str = "ContactsChanged"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Connection.Interface.ContactList"; +} diff --git a/src/telepathy/connection_interface_contacts.rs b/src/telepathy/connection_interface_contacts.rs new file mode 100644 index 0000000..5614faa --- /dev/null +++ b/src/telepathy/connection_interface_contacts.rs @@ -0,0 +1,99 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Connection_Interface_Contacts.xml -i org.freedesktop.Telepathy -o src/telepathy/connection_interface_contacts.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ConnectionInterfaceContacts { + fn get_contact_attributes( + &self, + handles: Vec, + interfaces: Vec<&str>, + hold: bool, + ) -> Result< + ::std::collections::HashMap< + u32, + ::std::collections::HashMap>>, + >, + tree::MethodErr, + >; + fn get_contact_by_id( + &self, + identifier: &str, + interfaces: Vec<&str>, + ) -> Result< + ( + u32, + ::std::collections::HashMap>>, + ), + tree::MethodErr, + >; + fn contact_attribute_interfaces(&self) -> Result, tree::MethodErr>; +} + +pub fn connection_interface_contacts_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + T: ConnectionInterfaceContacts, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface( + "org.freedesktop.Telepathy.Connection.Interface.Contacts", + data, + ); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let handles: Vec = i.read()?; + let interfaces: Vec<&str> = i.read()?; + let hold: bool = i.read()?; + let d = fclone(minfo); + let attributes = d.get_contact_attributes(handles, interfaces, hold)?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(attributes); + Ok(vec![rm]) + }; + let m = factory.method("GetContactAttributes", Default::default(), h); + let m = m.in_arg(("Handles", "au")); + let m = m.in_arg(("Interfaces", "as")); + let m = m.in_arg(("Hold", "b")); + let m = m.out_arg(("Attributes", "a{ua{sv}}")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let identifier: &str = i.read()?; + let interfaces: Vec<&str> = i.read()?; + let d = fclone(minfo); + let (handle, attributes) = d.get_contact_by_id(identifier, interfaces)?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(handle); + let rm = rm.append1(attributes); + Ok(vec![rm]) + }; + let m = factory.method("GetContactByID", Default::default(), h); + let m = m.in_arg(("Identifier", "s")); + let m = m.in_arg(("Interfaces", "as")); + let m = m.out_arg(("Handle", "u")); + let m = m.out_arg(("Attributes", "a{sv}")); + let i = i.add_m(m); + + let p = factory.property::, _>("ContactAttributeInterfaces", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.contact_attribute_interfaces()?); + Ok(()) + }); + let i = i.add_p(p); + i +} diff --git a/src/telepathy/connection_interface_forwarding.rs b/src/telepathy/connection_interface_forwarding.rs new file mode 100644 index 0000000..e0a4c28 --- /dev/null +++ b/src/telepathy/connection_interface_forwarding.rs @@ -0,0 +1,119 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Connection_Interface_Forwarding.xml -i org.freedesktop.Telepathy -o src/telepathy/connection_interface_forwarding.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ConnectionInterfaceForwardingDRAFT { + fn set_forwarding_rule( + &self, + condition: u32, + forwards: Vec<(u32, u32)>, + ) -> Result, tree::MethodErr>; + fn supported_forwarding_conditions( + &self, + ) -> Result<::std::collections::HashMap, tree::MethodErr>; + fn forwarding_rules( + &self, + ) -> Result<::std::collections::HashMap)>, tree::MethodErr>; +} + +pub fn connection_interface_forwarding_draft_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + D::Signal: Default, + T: ConnectionInterfaceForwardingDRAFT, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface( + "org.freedesktop.Telepathy.Connection.Interface.Forwarding.DRAFT", + data, + ); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let condition: u32 = i.read()?; + let forwards: Vec<(u32, u32)> = i.read()?; + let d = fclone(minfo); + let old_forwards = d.set_forwarding_rule(condition, forwards)?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(old_forwards); + Ok(vec![rm]) + }; + let m = factory.method("SetForwardingRule", Default::default(), h); + let m = m.in_arg(("Condition", "u")); + let m = m.in_arg(("Forwards", "a(uu)")); + let m = m.out_arg(("Old_Forwards", "a(uu)")); + let i = i.add_m(m); + + let p = factory.property::<::std::collections::HashMap, _>( + "SupportedForwardingConditions", + Default::default(), + ); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.supported_forwarding_conditions()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::<::std::collections::HashMap)>, _>( + "ForwardingRules", + Default::default(), + ); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.forwarding_rules()?); + Ok(()) + }); + let i = i.add_p(p); + let s = factory.signal("ForwardingRuleChanged", Default::default()); + let s = s.arg(("Condition", "u")); + let s = s.arg(("Timeout", "u")); + let s = s.arg(("Forwards", "a(uu)")); + let i = i.add_s(s); + i +} + +#[derive(Debug)] +pub struct ConnectionInterfaceForwardingDRAFTForwardingRuleChanged { + pub condition: u32, + pub timeout: u32, + pub forwards: Vec<(u32, u32)>, +} + +impl arg::AppendAll for ConnectionInterfaceForwardingDRAFTForwardingRuleChanged { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.condition, i); + arg::RefArg::append(&self.timeout, i); + arg::RefArg::append(&self.forwards, i); + } +} + +impl arg::ReadAll for ConnectionInterfaceForwardingDRAFTForwardingRuleChanged { + fn read(i: &mut arg::Iter) -> Result { + Ok(ConnectionInterfaceForwardingDRAFTForwardingRuleChanged { + condition: i.read()?, + timeout: i.read()?, + forwards: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for ConnectionInterfaceForwardingDRAFTForwardingRuleChanged { + const NAME: &'static str = "ForwardingRuleChanged"; + const INTERFACE: &'static str = + "org.freedesktop.Telepathy.Connection.Interface.Forwarding.DRAFT"; +} diff --git a/src/telepathy/connection_interface_irc_command1.rs b/src/telepathy/connection_interface_irc_command1.rs new file mode 100644 index 0000000..a913af7 --- /dev/null +++ b/src/telepathy/connection_interface_irc_command1.rs @@ -0,0 +1,39 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Connection_Interface_IRC_Command1.xml -i org.freedesktop.Telepathy -o src/telepathy/connection_interface_irc_command1.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ConnectionInterfaceIRCCommand1 { + fn send(&self, command: &str) -> Result<(), tree::MethodErr>; +} + +pub fn connection_interface_irccommand1_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + T: ConnectionInterfaceIRCCommand1, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface( + "org.freedesktop.Telepathy.Connection.Interface.IRCCommand1", + data, + ); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let command: &str = i.read()?; + let d = fclone(minfo); + d.send(command)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("Send", Default::default(), h); + let m = m.in_arg(("Command", "s")); + let i = i.add_m(m); + i +} diff --git a/src/telepathy/connection_interface_keepalive.rs b/src/telepathy/connection_interface_keepalive.rs new file mode 100644 index 0000000..586884e --- /dev/null +++ b/src/telepathy/connection_interface_keepalive.rs @@ -0,0 +1,46 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Connection_Interface_Keepalive.xml -i org.freedesktop.Telepathy -o src/telepathy/connection_interface_keepalive.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ConnectionInterfaceKeepaliveDRAFT { + fn keepalive_interval(&self) -> Result; + fn set_keepalive_interval(&self, value: u32) -> Result<(), tree::MethodErr>; +} + +pub fn connection_interface_keepalive_draft_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + T: ConnectionInterfaceKeepaliveDRAFT, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface( + "org.freedesktop.Telepathy.Connection.Interface.Keepalive.DRAFT", + data, + ); + let f = ::std::sync::Arc::new(f); + let p = factory.property::("KeepaliveInterval", Default::default()); + let p = p.access(tree::Access::ReadWrite); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.keepalive_interval()?); + Ok(()) + }); + let fclone = f.clone(); + let p = p.on_set(move |iter, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + d.set_keepalive_interval(iter.read()?)?; + Ok(()) + }); + let i = i.add_p(p); + i +} diff --git a/src/telepathy/connection_interface_location.rs b/src/telepathy/connection_interface_location.rs new file mode 100644 index 0000000..3e305a9 --- /dev/null +++ b/src/telepathy/connection_interface_location.rs @@ -0,0 +1,175 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Connection_Interface_Location.xml -i org.freedesktop.Telepathy -o src/telepathy/connection_interface_location.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ConnectionInterfaceLocation { + fn get_locations( + &self, + contacts: Vec, + ) -> Result< + ::std::collections::HashMap< + u32, + ::std::collections::HashMap>>, + >, + tree::MethodErr, + >; + fn request_location( + &self, + contact: u32, + ) -> Result< + ::std::collections::HashMap>>, + tree::MethodErr, + >; + fn set_location( + &self, + location: ::std::collections::HashMap<&str, arg::Variant>>, + ) -> Result<(), tree::MethodErr>; + fn location_access_control_types(&self) -> Result, tree::MethodErr>; + fn location_access_control( + &self, + ) -> Result<(u32, arg::Variant>), tree::MethodErr>; + fn set_location_access_control( + &self, + value: (u32, arg::Variant>), + ) -> Result<(), tree::MethodErr>; + fn supported_location_features(&self) -> Result; +} + +pub fn connection_interface_location_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + D::Signal: Default, + T: ConnectionInterfaceLocation, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface( + "org.freedesktop.Telepathy.Connection.Interface.Location", + data, + ); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let contacts: Vec = i.read()?; + let d = fclone(minfo); + let locations = d.get_locations(contacts)?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(locations); + Ok(vec![rm]) + }; + let m = factory.method("GetLocations", Default::default(), h); + let m = m.in_arg(("Contacts", "au")); + let m = m.out_arg(("Locations", "a{ua{sv}}")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let contact: u32 = i.read()?; + let d = fclone(minfo); + let location = d.request_location(contact)?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(location); + Ok(vec![rm]) + }; + let m = factory.method("RequestLocation", Default::default(), h); + let m = m.in_arg(("Contact", "u")); + let m = m.out_arg(("Location", "a{sv}")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let location: ::std::collections::HashMap<&str, arg::Variant>> = + i.read()?; + let d = fclone(minfo); + d.set_location(location)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("SetLocation", Default::default(), h); + let m = m.in_arg(("Location", "a{sv}")); + let i = i.add_m(m); + + let p = factory.property::, _>("LocationAccessControlTypes", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.location_access_control_types()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::<(u32, arg::Variant>), _>( + "LocationAccessControl", + Default::default(), + ); + let p = p.access(tree::Access::ReadWrite); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.location_access_control()?); + Ok(()) + }); + let fclone = f.clone(); + let p = p.on_set(move |iter, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + d.set_location_access_control(iter.read()?)?; + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("SupportedLocationFeatures", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.supported_location_features()?); + Ok(()) + }); + let i = i.add_p(p); + let s = factory.signal("LocationUpdated", Default::default()); + let s = s.arg(("Contact", "u")); + let s = s.arg(("Location", "a{sv}")); + let i = i.add_s(s); + i +} + +#[derive(Debug)] +pub struct ConnectionInterfaceLocationLocationUpdated { + pub contact: u32, + pub location: ::std::collections::HashMap>>, +} + +impl arg::AppendAll for ConnectionInterfaceLocationLocationUpdated { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.contact, i); + arg::RefArg::append(&self.location, i); + } +} + +impl arg::ReadAll for ConnectionInterfaceLocationLocationUpdated { + fn read(i: &mut arg::Iter) -> Result { + Ok(ConnectionInterfaceLocationLocationUpdated { + contact: i.read()?, + location: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for ConnectionInterfaceLocationLocationUpdated { + const NAME: &'static str = "LocationUpdated"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Connection.Interface.Location"; +} diff --git a/src/telepathy/connection_interface_mail_notification.rs b/src/telepathy/connection_interface_mail_notification.rs new file mode 100644 index 0000000..7affe3b --- /dev/null +++ b/src/telepathy/connection_interface_mail_notification.rs @@ -0,0 +1,183 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Connection_Interface_Mail_Notification.xml -i org.freedesktop.Telepathy -o src/telepathy/connection_interface_mail_notification.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ConnectionInterfaceMailNotification { + fn request_inbox_url(&self) -> Result<(String, u32, Vec<(String, String)>), tree::MethodErr>; + fn request_mail_url( + &self, + id: &str, + urldata: arg::Variant>, + ) -> Result<(String, u32, Vec<(String, String)>), tree::MethodErr>; + fn mail_notification_flags(&self) -> Result; + fn unread_mail_count(&self) -> Result; + fn unread_mails( + &self, + ) -> Result< + Vec<::std::collections::HashMap>>>, + tree::MethodErr, + >; + fn mail_address(&self) -> Result; +} + +pub fn connection_interface_mail_notification_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + D::Signal: Default, + T: ConnectionInterfaceMailNotification, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface( + "org.freedesktop.Telepathy.Connection.Interface.MailNotification", + data, + ); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let d = fclone(minfo); + let url = d.request_inbox_url()?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(url); + Ok(vec![rm]) + }; + let m = factory.method("RequestInboxURL", Default::default(), h); + let m = m.out_arg(("URL", "(sua(ss))")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let id: &str = i.read()?; + let urldata: arg::Variant> = i.read()?; + let d = fclone(minfo); + let url = d.request_mail_url(id, urldata)?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(url); + Ok(vec![rm]) + }; + let m = factory.method("RequestMailURL", Default::default(), h); + let m = m.in_arg(("ID", "s")); + let m = m.in_arg(("URL_Data", "v")); + let m = m.out_arg(("URL", "(sua(ss))")); + let i = i.add_m(m); + + let p = factory.property::("MailNotificationFlags", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.mail_notification_flags()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("UnreadMailCount", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.unread_mail_count()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory + .property::>>>, _>( + "UnreadMails", + Default::default(), + ); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.unread_mails()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::<&str, _>("MailAddress", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.mail_address()?); + Ok(()) + }); + let i = i.add_p(p); + let s = factory.signal("MailsReceived", Default::default()); + let s = s.arg(("Mails", "aa{sv}")); + let i = i.add_s(s); + let s = factory.signal("UnreadMailsChanged", Default::default()); + let s = s.arg(("Count", "u")); + let s = s.arg(("Mails_Added", "aa{sv}")); + let s = s.arg(("Mails_Removed", "as")); + let i = i.add_s(s); + i +} + +#[derive(Debug)] +pub struct ConnectionInterfaceMailNotificationMailsReceived { + pub mails: + Vec<::std::collections::HashMap>>>, +} + +impl arg::AppendAll for ConnectionInterfaceMailNotificationMailsReceived { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.mails, i); + } +} + +impl arg::ReadAll for ConnectionInterfaceMailNotificationMailsReceived { + fn read(i: &mut arg::Iter) -> Result { + Ok(ConnectionInterfaceMailNotificationMailsReceived { mails: i.read()? }) + } +} + +impl dbus::message::SignalArgs for ConnectionInterfaceMailNotificationMailsReceived { + const NAME: &'static str = "MailsReceived"; + const INTERFACE: &'static str = + "org.freedesktop.Telepathy.Connection.Interface.MailNotification"; +} + +#[derive(Debug)] +pub struct ConnectionInterfaceMailNotificationUnreadMailsChanged { + pub count: u32, + pub mails_added: + Vec<::std::collections::HashMap>>>, + pub mails_removed: Vec, +} + +impl arg::AppendAll for ConnectionInterfaceMailNotificationUnreadMailsChanged { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.count, i); + arg::RefArg::append(&self.mails_added, i); + arg::RefArg::append(&self.mails_removed, i); + } +} + +impl arg::ReadAll for ConnectionInterfaceMailNotificationUnreadMailsChanged { + fn read(i: &mut arg::Iter) -> Result { + Ok(ConnectionInterfaceMailNotificationUnreadMailsChanged { + count: i.read()?, + mails_added: i.read()?, + mails_removed: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for ConnectionInterfaceMailNotificationUnreadMailsChanged { + const NAME: &'static str = "UnreadMailsChanged"; + const INTERFACE: &'static str = + "org.freedesktop.Telepathy.Connection.Interface.MailNotification"; +} diff --git a/src/telepathy/connection_interface_power_saving.rs b/src/telepathy/connection_interface_power_saving.rs new file mode 100644 index 0000000..7f7fda2 --- /dev/null +++ b/src/telepathy/connection_interface_power_saving.rs @@ -0,0 +1,78 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Connection_Interface_Power_Saving.xml -i org.freedesktop.Telepathy -o src/telepathy/connection_interface_power_saving.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ConnectionInterfacePowerSaving { + fn set_power_saving(&self, activate: bool) -> Result<(), tree::MethodErr>; + fn power_saving_active(&self) -> Result; +} + +pub fn connection_interface_power_saving_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + D::Signal: Default, + T: ConnectionInterfacePowerSaving, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface( + "org.freedesktop.Telepathy.Connection.Interface.PowerSaving", + data, + ); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let activate: bool = i.read()?; + let d = fclone(minfo); + d.set_power_saving(activate)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("SetPowerSaving", Default::default(), h); + let m = m.in_arg(("Activate", "b")); + let i = i.add_m(m); + + let p = factory.property::("PowerSavingActive", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.power_saving_active()?); + Ok(()) + }); + let i = i.add_p(p); + let s = factory.signal("PowerSavingChanged", Default::default()); + let s = s.arg(("Active", "b")); + let i = i.add_s(s); + i +} + +#[derive(Debug)] +pub struct ConnectionInterfacePowerSavingPowerSavingChanged { + pub active: bool, +} + +impl arg::AppendAll for ConnectionInterfacePowerSavingPowerSavingChanged { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.active, i); + } +} + +impl arg::ReadAll for ConnectionInterfacePowerSavingPowerSavingChanged { + fn read(i: &mut arg::Iter) -> Result { + Ok(ConnectionInterfacePowerSavingPowerSavingChanged { active: i.read()? }) + } +} + +impl dbus::message::SignalArgs for ConnectionInterfacePowerSavingPowerSavingChanged { + const NAME: &'static str = "PowerSavingChanged"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Connection.Interface.PowerSaving"; +} diff --git a/src/telepathy/connection_interface_presence.rs b/src/telepathy/connection_interface_presence.rs new file mode 100644 index 0000000..42af2c4 --- /dev/null +++ b/src/telepathy/connection_interface_presence.rs @@ -0,0 +1,214 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Connection_Interface_Presence.xml -i org.freedesktop.Telepathy -o src/telepathy/connection_interface_presence.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ConnectionInterfacePresence { + fn add_status( + &self, + status: &str, + parameters: ::std::collections::HashMap<&str, arg::Variant>>, + ) -> Result<(), tree::MethodErr>; + fn clear_status(&self) -> Result<(), tree::MethodErr>; + fn get_presence( + &self, + contacts: Vec, + ) -> Result< + ::std::collections::HashMap< + u32, + ( + u32, + ::std::collections::HashMap< + String, + ::std::collections::HashMap< + String, + arg::Variant>, + >, + >, + ), + >, + tree::MethodErr, + >; + fn get_statuses( + &self, + ) -> Result< + ::std::collections::HashMap< + String, + (u32, bool, bool, ::std::collections::HashMap), + >, + tree::MethodErr, + >; + fn remove_status(&self, status: &str) -> Result<(), tree::MethodErr>; + fn request_presence(&self, contacts: Vec) -> Result<(), tree::MethodErr>; + fn set_last_activity_time(&self, time: u32) -> Result<(), tree::MethodErr>; + fn set_status( + &self, + statuses: ::std::collections::HashMap< + &str, + ::std::collections::HashMap<&str, arg::Variant>>, + >, + ) -> Result<(), tree::MethodErr>; +} + +pub fn connection_interface_presence_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Signal: Default, + T: ConnectionInterfacePresence, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface( + "org.freedesktop.Telepathy.Connection.Interface.Presence", + data, + ); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let status: &str = i.read()?; + let parameters: ::std::collections::HashMap<&str, arg::Variant>> = + i.read()?; + let d = fclone(minfo); + d.add_status(status, parameters)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("AddStatus", Default::default(), h); + let m = m.in_arg(("Status", "s")); + let m = m.in_arg(("Parameters", "a{sv}")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let d = fclone(minfo); + d.clear_status()?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("ClearStatus", Default::default(), h); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let contacts: Vec = i.read()?; + let d = fclone(minfo); + let presence = d.get_presence(contacts)?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(presence); + Ok(vec![rm]) + }; + let m = factory.method("GetPresence", Default::default(), h); + let m = m.in_arg(("Contacts", "au")); + let m = m.out_arg(("Presence", "a{u(ua{sa{sv}})}")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let d = fclone(minfo); + let available_statuses = d.get_statuses()?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(available_statuses); + Ok(vec![rm]) + }; + let m = factory.method("GetStatuses", Default::default(), h); + let m = m.out_arg(("Available_Statuses", "a{s(ubba{ss})}")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let status: &str = i.read()?; + let d = fclone(minfo); + d.remove_status(status)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("RemoveStatus", Default::default(), h); + let m = m.in_arg(("Status", "s")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let contacts: Vec = i.read()?; + let d = fclone(minfo); + d.request_presence(contacts)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("RequestPresence", Default::default(), h); + let m = m.in_arg(("Contacts", "au")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let time: u32 = i.read()?; + let d = fclone(minfo); + d.set_last_activity_time(time)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("SetLastActivityTime", Default::default(), h); + let m = m.in_arg(("Time", "u")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let statuses: ::std::collections::HashMap< + &str, + ::std::collections::HashMap<&str, arg::Variant>>, + > = i.read()?; + let d = fclone(minfo); + d.set_status(statuses)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("SetStatus", Default::default(), h); + let m = m.in_arg(("Statuses", "a{sa{sv}}")); + let i = i.add_m(m); + let s = factory.signal("PresenceUpdate", Default::default()); + let s = s.arg(("Presence", "a{u(ua{sa{sv}})}")); + let i = i.add_s(s); + i +} + +#[derive(Debug)] +pub struct ConnectionInterfacePresencePresenceUpdate { + pub presence: ::std::collections::HashMap< + u32, + ( + u32, + ::std::collections::HashMap< + String, + ::std::collections::HashMap>>, + >, + ), + >, +} + +impl arg::AppendAll for ConnectionInterfacePresencePresenceUpdate { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.presence, i); + } +} + +impl arg::ReadAll for ConnectionInterfacePresencePresenceUpdate { + fn read(i: &mut arg::Iter) -> Result { + Ok(ConnectionInterfacePresencePresenceUpdate { + presence: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for ConnectionInterfacePresencePresenceUpdate { + const NAME: &'static str = "PresenceUpdate"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Connection.Interface.Presence"; +} diff --git a/src/telepathy/connection_interface_privacy.rs b/src/telepathy/connection_interface_privacy.rs new file mode 100644 index 0000000..b9b51df --- /dev/null +++ b/src/telepathy/connection_interface_privacy.rs @@ -0,0 +1,91 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Connection_Interface_Privacy.xml -i org.freedesktop.Telepathy -o src/telepathy/connection_interface_privacy.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ConnectionInterfacePrivacy { + fn get_privacy_mode(&self) -> Result; + fn get_privacy_modes(&self) -> Result, tree::MethodErr>; + fn set_privacy_mode(&self, mode: &str) -> Result<(), tree::MethodErr>; +} + +pub fn connection_interface_privacy_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Signal: Default, + T: ConnectionInterfacePrivacy, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface( + "org.freedesktop.Telepathy.Connection.Interface.Privacy", + data, + ); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let d = fclone(minfo); + let arg0 = d.get_privacy_mode()?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(arg0); + Ok(vec![rm]) + }; + let m = factory.method("GetPrivacyMode", Default::default(), h); + let m = m.out_arg(("", "s")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let d = fclone(minfo); + let arg0 = d.get_privacy_modes()?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(arg0); + Ok(vec![rm]) + }; + let m = factory.method("GetPrivacyModes", Default::default(), h); + let m = m.out_arg(("", "as")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let mode: &str = i.read()?; + let d = fclone(minfo); + d.set_privacy_mode(mode)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("SetPrivacyMode", Default::default(), h); + let m = m.in_arg(("Mode", "s")); + let i = i.add_m(m); + let s = factory.signal("PrivacyModeChanged", Default::default()); + let s = s.arg(("Mode", "s")); + let i = i.add_s(s); + i +} + +#[derive(Debug)] +pub struct ConnectionInterfacePrivacyPrivacyModeChanged { + pub mode: String, +} + +impl arg::AppendAll for ConnectionInterfacePrivacyPrivacyModeChanged { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.mode, i); + } +} + +impl arg::ReadAll for ConnectionInterfacePrivacyPrivacyModeChanged { + fn read(i: &mut arg::Iter) -> Result { + Ok(ConnectionInterfacePrivacyPrivacyModeChanged { mode: i.read()? }) + } +} + +impl dbus::message::SignalArgs for ConnectionInterfacePrivacyPrivacyModeChanged { + const NAME: &'static str = "PrivacyModeChanged"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Connection.Interface.Privacy"; +} diff --git a/src/telepathy/connection_interface_renaming.rs b/src/telepathy/connection_interface_renaming.rs new file mode 100644 index 0000000..559af6c --- /dev/null +++ b/src/telepathy/connection_interface_renaming.rs @@ -0,0 +1,71 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Connection_Interface_Renaming.xml -i org.freedesktop.Telepathy -o src/telepathy/connection_interface_renaming.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ConnectionInterfaceRenaming { + fn request_rename(&self, identifier: &str) -> Result<(), tree::MethodErr>; +} + +pub fn connection_interface_renaming_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Signal: Default, + T: ConnectionInterfaceRenaming, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface( + "org.freedesktop.Telepathy.Connection.Interface.Renaming", + data, + ); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let identifier: &str = i.read()?; + let d = fclone(minfo); + d.request_rename(identifier)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("RequestRename", Default::default(), h); + let m = m.in_arg(("Identifier", "s")); + let i = i.add_m(m); + let s = factory.signal("Renamed", Default::default()); + let s = s.arg(("Original", "u")); + let s = s.arg(("New", "u")); + let i = i.add_s(s); + i +} + +#[derive(Debug)] +pub struct ConnectionInterfaceRenamingRenamed { + pub original: u32, + pub new: u32, +} + +impl arg::AppendAll for ConnectionInterfaceRenamingRenamed { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.original, i); + arg::RefArg::append(&self.new, i); + } +} + +impl arg::ReadAll for ConnectionInterfaceRenamingRenamed { + fn read(i: &mut arg::Iter) -> Result { + Ok(ConnectionInterfaceRenamingRenamed { + original: i.read()?, + new: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for ConnectionInterfaceRenamingRenamed { + const NAME: &'static str = "Renamed"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Connection.Interface.Renaming"; +} diff --git a/src/telepathy/connection_interface_requests.rs b/src/telepathy/connection_interface_requests.rs new file mode 100644 index 0000000..b6762e9 --- /dev/null +++ b/src/telepathy/connection_interface_requests.rs @@ -0,0 +1,187 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Connection_Interface_Requests.xml -i org.freedesktop.Telepathy -o src/telepathy/connection_interface_requests.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ConnectionInterfaceRequests { + fn create_channel( + &self, + request: ::std::collections::HashMap<&str, arg::Variant>>, + ) -> Result< + ( + dbus::Path<'static>, + ::std::collections::HashMap>>, + ), + tree::MethodErr, + >; + fn ensure_channel( + &self, + request: ::std::collections::HashMap<&str, arg::Variant>>, + ) -> Result< + ( + bool, + dbus::Path<'static>, + ::std::collections::HashMap>>, + ), + tree::MethodErr, + >; + fn channels( + &self, + ) -> Result< + Vec<( + dbus::Path<'static>, + ::std::collections::HashMap>>, + )>, + tree::MethodErr, + >; + fn requestable_channel_classes( + &self, + ) -> Result< + Vec<( + ::std::collections::HashMap>>, + Vec, + )>, + tree::MethodErr, + >; +} + +pub fn connection_interface_requests_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + D::Signal: Default, + T: ConnectionInterfaceRequests, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface( + "org.freedesktop.Telepathy.Connection.Interface.Requests", + data, + ); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let request: ::std::collections::HashMap<&str, arg::Variant>> = + i.read()?; + let d = fclone(minfo); + let (channel, properties) = d.create_channel(request)?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(channel); + let rm = rm.append1(properties); + Ok(vec![rm]) + }; + let m = factory.method("CreateChannel", Default::default(), h); + let m = m.in_arg(("Request", "a{sv}")); + let m = m.out_arg(("Channel", "o")); + let m = m.out_arg(("Properties", "a{sv}")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let request: ::std::collections::HashMap<&str, arg::Variant>> = + i.read()?; + let d = fclone(minfo); + let (yours, channel, properties) = d.ensure_channel(request)?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(yours); + let rm = rm.append1(channel); + let rm = rm.append1(properties); + Ok(vec![rm]) + }; + let m = factory.method("EnsureChannel", Default::default(), h); + let m = m.in_arg(("Request", "a{sv}")); + let m = m.out_arg(("Yours", "b")); + let m = m.out_arg(("Channel", "o")); + let m = m.out_arg(("Properties", "a{sv}")); + let i = i.add_m(m); + + let p = factory.property::>>, + )>, _>("Channels", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.channels()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::>>, + Vec<&str>, + )>, _>("RequestableChannelClasses", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.requestable_channel_classes()?); + Ok(()) + }); + let i = i.add_p(p); + let s = factory.signal("NewChannels", Default::default()); + let s = s.arg(("Channels", "a(oa{sv})")); + let i = i.add_s(s); + let s = factory.signal("ChannelClosed", Default::default()); + let s = s.arg(("Removed", "o")); + let i = i.add_s(s); + i +} + +#[derive(Debug)] +pub struct ConnectionInterfaceRequestsNewChannels { + pub channels: Vec<( + dbus::Path<'static>, + ::std::collections::HashMap>>, + )>, +} + +impl arg::AppendAll for ConnectionInterfaceRequestsNewChannels { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.channels, i); + } +} + +impl arg::ReadAll for ConnectionInterfaceRequestsNewChannels { + fn read(i: &mut arg::Iter) -> Result { + Ok(ConnectionInterfaceRequestsNewChannels { + channels: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for ConnectionInterfaceRequestsNewChannels { + const NAME: &'static str = "NewChannels"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Connection.Interface.Requests"; +} + +#[derive(Debug)] +pub struct ConnectionInterfaceRequestsChannelClosed { + pub removed: dbus::Path<'static>, +} + +impl arg::AppendAll for ConnectionInterfaceRequestsChannelClosed { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.removed, i); + } +} + +impl arg::ReadAll for ConnectionInterfaceRequestsChannelClosed { + fn read(i: &mut arg::Iter) -> Result { + Ok(ConnectionInterfaceRequestsChannelClosed { removed: i.read()? }) + } +} + +impl dbus::message::SignalArgs for ConnectionInterfaceRequestsChannelClosed { + const NAME: &'static str = "ChannelClosed"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Connection.Interface.Requests"; +} diff --git a/src/telepathy/connection_interface_resources.rs b/src/telepathy/connection_interface_resources.rs new file mode 100644 index 0000000..c015f24 --- /dev/null +++ b/src/telepathy/connection_interface_resources.rs @@ -0,0 +1,102 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Connection_Interface_Resources.xml -i org.freedesktop.Telepathy -o src/telepathy/connection_interface_resources.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ConnectionInterfaceResourcesDRAFT { + fn get_resources( + &self, + contacts: Vec, + ) -> Result< + ::std::collections::HashMap< + u32, + ::std::collections::HashMap< + String, + ::std::collections::HashMap>>, + >, + >, + tree::MethodErr, + >; + fn resources_human_readable(&self) -> Result; +} + +pub fn connection_interface_resources_draft_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + D::Signal: Default, + T: ConnectionInterfaceResourcesDRAFT, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface( + "org.freedesktop.Telepathy.Connection.Interface.Resources.DRAFT", + data, + ); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let contacts: Vec = i.read()?; + let d = fclone(minfo); + let resources = d.get_resources(contacts)?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(resources); + Ok(vec![rm]) + }; + let m = factory.method("GetResources", Default::default(), h); + let m = m.in_arg(("Contacts", "au")); + let m = m.out_arg(("Resources", "a{ua{sa{sv}}}")); + let i = i.add_m(m); + + let p = factory.property::("ResourcesHumanReadable", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.resources_human_readable()?); + Ok(()) + }); + let i = i.add_p(p); + let s = factory.signal("ResourcesUpdated", Default::default()); + let s = s.arg(("Contact", "u")); + let s = s.arg(("Resources", "a{sa{sv}}")); + let i = i.add_s(s); + i +} + +#[derive(Debug)] +pub struct ConnectionInterfaceResourcesDRAFTResourcesUpdated { + pub contact: u32, + pub resources: ::std::collections::HashMap< + String, + ::std::collections::HashMap>>, + >, +} + +impl arg::AppendAll for ConnectionInterfaceResourcesDRAFTResourcesUpdated { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.contact, i); + arg::RefArg::append(&self.resources, i); + } +} + +impl arg::ReadAll for ConnectionInterfaceResourcesDRAFTResourcesUpdated { + fn read(i: &mut arg::Iter) -> Result { + Ok(ConnectionInterfaceResourcesDRAFTResourcesUpdated { + contact: i.read()?, + resources: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for ConnectionInterfaceResourcesDRAFTResourcesUpdated { + const NAME: &'static str = "ResourcesUpdated"; + const INTERFACE: &'static str = + "org.freedesktop.Telepathy.Connection.Interface.Resources.DRAFT"; +} diff --git a/src/telepathy/connection_interface_service_point.rs b/src/telepathy/connection_interface_service_point.rs new file mode 100644 index 0000000..74564cd --- /dev/null +++ b/src/telepathy/connection_interface_service_point.rs @@ -0,0 +1,67 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Connection_Interface_Service_Point.xml -i org.freedesktop.Telepathy -o src/telepathy/connection_interface_service_point.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ConnectionInterfaceServicePoint { + fn known_service_points(&self) -> Result)>, tree::MethodErr>; +} + +pub fn connection_interface_service_point_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + D::Signal: Default, + T: ConnectionInterfaceServicePoint, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface( + "org.freedesktop.Telepathy.Connection.Interface.ServicePoint", + data, + ); + let f = ::std::sync::Arc::new(f); + let p = factory + .property::)>, _>("KnownServicePoints", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.known_service_points()?); + Ok(()) + }); + let i = i.add_p(p); + let s = factory.signal("ServicePointsChanged", Default::default()); + let s = s.arg(("Service_Points", "a((us)as)")); + let i = i.add_s(s); + i +} + +#[derive(Debug)] +pub struct ConnectionInterfaceServicePointServicePointsChanged { + pub service_points: Vec<((u32, String), Vec)>, +} + +impl arg::AppendAll for ConnectionInterfaceServicePointServicePointsChanged { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.service_points, i); + } +} + +impl arg::ReadAll for ConnectionInterfaceServicePointServicePointsChanged { + fn read(i: &mut arg::Iter) -> Result { + Ok(ConnectionInterfaceServicePointServicePointsChanged { + service_points: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for ConnectionInterfaceServicePointServicePointsChanged { + const NAME: &'static str = "ServicePointsChanged"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Connection.Interface.ServicePoint"; +} diff --git a/src/telepathy/connection_interface_sidecars1.rs b/src/telepathy/connection_interface_sidecars1.rs new file mode 100644 index 0000000..a9004c8 --- /dev/null +++ b/src/telepathy/connection_interface_sidecars1.rs @@ -0,0 +1,52 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Connection_Interface_Sidecars1.xml -i org.freedesktop.Telepathy -o src/telepathy/connection_interface_sidecars1.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ConnectionInterfaceSidecars1 { + fn ensure_sidecar( + &self, + main_interface: &str, + ) -> Result< + ( + dbus::Path<'static>, + ::std::collections::HashMap>>, + ), + tree::MethodErr, + >; +} + +pub fn connection_interface_sidecars1_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + T: ConnectionInterfaceSidecars1, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface( + "org.freedesktop.Telepathy.Connection.Interface.Sidecars1", + data, + ); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let main_interface: &str = i.read()?; + let d = fclone(minfo); + let (path, properties) = d.ensure_sidecar(main_interface)?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(path); + let rm = rm.append1(properties); + Ok(vec![rm]) + }; + let m = factory.method("EnsureSidecar", Default::default(), h); + let m = m.in_arg(("Main_Interface", "s")); + let m = m.out_arg(("Path", "o")); + let m = m.out_arg(("Properties", "a{sv}")); + let i = i.add_m(m); + i +} diff --git a/src/telepathy/connection_interface_simple_presence.rs b/src/telepathy/connection_interface_simple_presence.rs new file mode 100644 index 0000000..c132a14 --- /dev/null +++ b/src/telepathy/connection_interface_simple_presence.rs @@ -0,0 +1,118 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Connection_Interface_Simple_Presence.xml -i org.freedesktop.Telepathy -o src/telepathy/connection_interface_simple_presence.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ConnectionInterfaceSimplePresence { + fn set_presence(&self, status: &str, status_message: &str) -> Result<(), tree::MethodErr>; + fn get_presences( + &self, + contacts: Vec, + ) -> Result<::std::collections::HashMap, tree::MethodErr>; + fn statuses( + &self, + ) -> Result<::std::collections::HashMap, tree::MethodErr>; + fn maximum_status_message_length(&self) -> Result; +} + +pub fn connection_interface_simple_presence_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + D::Signal: Default, + T: ConnectionInterfaceSimplePresence, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface( + "org.freedesktop.Telepathy.Connection.Interface.SimplePresence", + data, + ); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let status: &str = i.read()?; + let status_message: &str = i.read()?; + let d = fclone(minfo); + d.set_presence(status, status_message)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("SetPresence", Default::default(), h); + let m = m.in_arg(("Status", "s")); + let m = m.in_arg(("Status_Message", "s")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let contacts: Vec = i.read()?; + let d = fclone(minfo); + let presence = d.get_presences(contacts)?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(presence); + Ok(vec![rm]) + }; + let m = factory.method("GetPresences", Default::default(), h); + let m = m.in_arg(("Contacts", "au")); + let m = m.out_arg(("Presence", "a{u(uss)}")); + let i = i.add_m(m); + + let p = factory.property::<::std::collections::HashMap<&str, (u32, bool, bool)>, _>( + "Statuses", + Default::default(), + ); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.statuses()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("MaximumStatusMessageLength", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.maximum_status_message_length()?); + Ok(()) + }); + let i = i.add_p(p); + let s = factory.signal("PresencesChanged", Default::default()); + let s = s.arg(("Presence", "a{u(uss)}")); + let i = i.add_s(s); + i +} + +#[derive(Debug)] +pub struct ConnectionInterfaceSimplePresencePresencesChanged { + pub presence: ::std::collections::HashMap, +} + +impl arg::AppendAll for ConnectionInterfaceSimplePresencePresencesChanged { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.presence, i); + } +} + +impl arg::ReadAll for ConnectionInterfaceSimplePresencePresencesChanged { + fn read(i: &mut arg::Iter) -> Result { + Ok(ConnectionInterfaceSimplePresencePresencesChanged { + presence: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for ConnectionInterfaceSimplePresencePresencesChanged { + const NAME: &'static str = "PresencesChanged"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Connection.Interface.SimplePresence"; +} diff --git a/src/telepathy/connection_manager.rs b/src/telepathy/connection_manager.rs new file mode 100644 index 0000000..c52e967 --- /dev/null +++ b/src/telepathy/connection_manager.rs @@ -0,0 +1,159 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Connection_Manager.xml -i org.freedesktop.Telepathy -o src/telepathy/connection_manager.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ConnectionManager { + fn get_parameters( + &self, + protocol: &str, + ) -> Result< + Vec<( + String, + u32, + String, + arg::Variant>, + )>, + tree::MethodErr, + >; + fn list_protocols(&self) -> Result, tree::MethodErr>; + fn request_connection( + &self, + protocol: &str, + parameters: ::std::collections::HashMap<&str, arg::Variant>>, + ) -> Result<(String, dbus::Path<'static>), tree::MethodErr>; + fn protocols( + &self, + ) -> Result< + ::std::collections::HashMap< + String, + ::std::collections::HashMap>>, + >, + tree::MethodErr, + >; + fn interfaces(&self) -> Result, tree::MethodErr>; +} + +pub fn connection_manager_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + D::Signal: Default, + T: ConnectionManager, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface("org.freedesktop.Telepathy.ConnectionManager", data); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let protocol: &str = i.read()?; + let d = fclone(minfo); + let parameters = d.get_parameters(protocol)?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(parameters); + Ok(vec![rm]) + }; + let m = factory.method("GetParameters", Default::default(), h); + let m = m.in_arg(("Protocol", "s")); + let m = m.out_arg(("Parameters", "a(susv)")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let d = fclone(minfo); + let protocols = d.list_protocols()?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(protocols); + Ok(vec![rm]) + }; + let m = factory.method("ListProtocols", Default::default(), h); + let m = m.out_arg(("Protocols", "as")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let protocol: &str = i.read()?; + let parameters: ::std::collections::HashMap<&str, arg::Variant>> = + i.read()?; + let d = fclone(minfo); + let (bus_name, object_path) = d.request_connection(protocol, parameters)?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(bus_name); + let rm = rm.append1(object_path); + Ok(vec![rm]) + }; + let m = factory.method("RequestConnection", Default::default(), h); + let m = m.in_arg(("Protocol", "s")); + let m = m.in_arg(("Parameters", "a{sv}")); + let m = m.out_arg(("Bus_Name", "s")); + let m = m.out_arg(("Object_Path", "o")); + let i = i.add_m(m); + + let p = factory.property::<::std::collections::HashMap< + &str, + ::std::collections::HashMap<&str, arg::Variant>>, + >, _>("Protocols", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.protocols()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::, _>("Interfaces", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.interfaces()?); + Ok(()) + }); + let i = i.add_p(p); + let s = factory.signal("NewConnection", Default::default()); + let s = s.arg(("Bus_Name", "s")); + let s = s.arg(("Object_Path", "o")); + let s = s.arg(("Protocol", "s")); + let i = i.add_s(s); + i +} + +#[derive(Debug)] +pub struct ConnectionManagerNewConnection { + pub bus_name: String, + pub object_path: dbus::Path<'static>, + pub protocol: String, +} + +impl arg::AppendAll for ConnectionManagerNewConnection { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.bus_name, i); + arg::RefArg::append(&self.object_path, i); + arg::RefArg::append(&self.protocol, i); + } +} + +impl arg::ReadAll for ConnectionManagerNewConnection { + fn read(i: &mut arg::Iter) -> Result { + Ok(ConnectionManagerNewConnection { + bus_name: i.read()?, + object_path: i.read()?, + protocol: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for ConnectionManagerNewConnection { + const NAME: &'static str = "NewConnection"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.ConnectionManager"; +} diff --git a/src/telepathy/connection_manager_interface_account_storage.rs b/src/telepathy/connection_manager_interface_account_storage.rs new file mode 100644 index 0000000..cf98ff1 --- /dev/null +++ b/src/telepathy/connection_manager_interface_account_storage.rs @@ -0,0 +1,67 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Connection_Manager_Interface_Account_Storage.xml -i org.freedesktop.Telepathy -o src/telepathy/connection_manager_interface_account_storage.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ConnectionManagerInterfaceAccountStorageDRAFT { + fn forget_credentials(&self, account_id: &str) -> Result<(), tree::MethodErr>; + fn remove_account(&self, account_id: &str) -> Result<(), tree::MethodErr>; + fn accounts(&self) -> Result<::std::collections::HashMap, tree::MethodErr>; +} + +pub fn connection_manager_interface_account_storage_draft_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + T: ConnectionManagerInterfaceAccountStorageDRAFT, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface( + "org.freedesktop.Telepathy.ConnectionManager.Interface.AccountStorage.DRAFT", + data, + ); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let account_id: &str = i.read()?; + let d = fclone(minfo); + d.forget_credentials(account_id)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("ForgetCredentials", Default::default(), h); + let m = m.in_arg(("Account_Id", "s")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let account_id: &str = i.read()?; + let d = fclone(minfo); + d.remove_account(account_id)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("RemoveAccount", Default::default(), h); + let m = m.in_arg(("Account_Id", "s")); + let i = i.add_m(m); + + let p = factory + .property::<::std::collections::HashMap<&str, u32>, _>("Accounts", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.accounts()?); + Ok(()) + }); + let i = i.add_p(p); + i +} diff --git a/src/telepathy/debug.rs b/src/telepathy/debug.rs new file mode 100644 index 0000000..84670b8 --- /dev/null +++ b/src/telepathy/debug.rs @@ -0,0 +1,96 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Debug.xml -i org.freedesktop.Telepathy -o src/telepathy/debug.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait Debug { + fn get_messages(&self) -> Result, tree::MethodErr>; + fn enabled(&self) -> Result; + fn set_enabled(&self, value: bool) -> Result<(), tree::MethodErr>; +} + +pub fn debug_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + D::Signal: Default, + T: Debug, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface("org.freedesktop.Telepathy.Debug", data); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let d = fclone(minfo); + let messages = d.get_messages()?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(messages); + Ok(vec![rm]) + }; + let m = factory.method("GetMessages", Default::default(), h); + let m = m.out_arg(("Messages", "a(dsus)")); + let i = i.add_m(m); + + let p = factory.property::("Enabled", Default::default()); + let p = p.access(tree::Access::ReadWrite); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.enabled()?); + Ok(()) + }); + let fclone = f.clone(); + let p = p.on_set(move |iter, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + d.set_enabled(iter.read()?)?; + Ok(()) + }); + let i = i.add_p(p); + let s = factory.signal("NewDebugMessage", Default::default()); + let s = s.arg(("time", "d")); + let s = s.arg(("domain", "s")); + let s = s.arg(("level", "u")); + let s = s.arg(("message", "s")); + let i = i.add_s(s); + i +} + +#[derive(Debug)] +pub struct DebugNewDebugMessage { + pub time: f64, + pub domain: String, + pub level: u32, + pub message: String, +} + +impl arg::AppendAll for DebugNewDebugMessage { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.time, i); + arg::RefArg::append(&self.domain, i); + arg::RefArg::append(&self.level, i); + arg::RefArg::append(&self.message, i); + } +} + +impl arg::ReadAll for DebugNewDebugMessage { + fn read(i: &mut arg::Iter) -> Result { + Ok(DebugNewDebugMessage { + time: i.read()?, + domain: i.read()?, + level: i.read()?, + message: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for DebugNewDebugMessage { + const NAME: &'static str = "NewDebugMessage"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Debug"; +} diff --git a/src/telepathy/errors.rs b/src/telepathy/errors.rs new file mode 100644 index 0000000..633f252 --- /dev/null +++ b/src/telepathy/errors.rs @@ -0,0 +1,4 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/errors.xml -i org.freedesktop.Telepathy -o src/telepathy/errors.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; diff --git a/src/telepathy/generic_types.rs b/src/telepathy/generic_types.rs new file mode 100644 index 0000000..79b47c7 --- /dev/null +++ b/src/telepathy/generic_types.rs @@ -0,0 +1,4 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/generic-types.xml -i org.freedesktop.Telepathy -o src/telepathy/generic_types.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; diff --git a/src/telepathy/media_session_handler.rs b/src/telepathy/media_session_handler.rs new file mode 100644 index 0000000..64986fb --- /dev/null +++ b/src/telepathy/media_session_handler.rs @@ -0,0 +1,89 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Media_Session_Handler.xml -i org.freedesktop.Telepathy -o src/telepathy/media_session_handler.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait MediaSessionHandler { + fn error(&self, error_code: u32, message: &str) -> Result<(), tree::MethodErr>; + fn ready(&self) -> Result<(), tree::MethodErr>; +} + +pub fn media_session_handler_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Signal: Default, + T: MediaSessionHandler, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface("org.freedesktop.Telepathy.Media.SessionHandler", data); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let error_code: u32 = i.read()?; + let message: &str = i.read()?; + let d = fclone(minfo); + d.error(error_code, message)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("Error", Default::default(), h); + let m = m.in_arg(("Error_Code", "u")); + let m = m.in_arg(("Message", "s")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let d = fclone(minfo); + d.ready()?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("Ready", Default::default(), h); + let i = i.add_m(m); + let s = factory.signal("NewStreamHandler", Default::default()); + let s = s.arg(("Stream_Handler", "o")); + let s = s.arg(("ID", "u")); + let s = s.arg(("Media_Type", "u")); + let s = s.arg(("Direction", "u")); + let i = i.add_s(s); + i +} + +#[derive(Debug)] +pub struct MediaSessionHandlerNewStreamHandler { + pub stream_handler: dbus::Path<'static>, + pub id: u32, + pub media_type: u32, + pub direction: u32, +} + +impl arg::AppendAll for MediaSessionHandlerNewStreamHandler { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.stream_handler, i); + arg::RefArg::append(&self.id, i); + arg::RefArg::append(&self.media_type, i); + arg::RefArg::append(&self.direction, i); + } +} + +impl arg::ReadAll for MediaSessionHandlerNewStreamHandler { + fn read(i: &mut arg::Iter) -> Result { + Ok(MediaSessionHandlerNewStreamHandler { + stream_handler: i.read()?, + id: i.read()?, + media_type: i.read()?, + direction: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for MediaSessionHandlerNewStreamHandler { + const NAME: &'static str = "NewStreamHandler"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Media.SessionHandler"; +} diff --git a/src/telepathy/media_stream_handler.rs b/src/telepathy/media_stream_handler.rs new file mode 100644 index 0000000..42902ee --- /dev/null +++ b/src/telepathy/media_stream_handler.rs @@ -0,0 +1,814 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Media_Stream_Handler.xml -i org.freedesktop.Telepathy -o src/telepathy/media_stream_handler.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait MediaStreamHandler { + fn codec_choice(&self, codec_id: u32) -> Result<(), tree::MethodErr>; + fn error(&self, error_code: u32, message: &str) -> Result<(), tree::MethodErr>; + fn native_candidates_prepared(&self) -> Result<(), tree::MethodErr>; + fn new_active_candidate_pair( + &self, + native_candidate_id: &str, + remote_candidate_id: &str, + ) -> Result<(), tree::MethodErr>; + fn new_active_transport_pair( + &self, + native_candidate_id: &str, + native_transport: (u32, &str, u32, u32, &str, &str, f64, u32, &str, &str), + remote_candidate_id: &str, + remote_transport: (u32, &str, u32, u32, &str, &str, f64, u32, &str, &str), + ) -> Result<(), tree::MethodErr>; + fn new_native_candidate( + &self, + candidate_id: &str, + transports: Vec<(u32, &str, u32, u32, &str, &str, f64, u32, &str, &str)>, + ) -> Result<(), tree::MethodErr>; + fn ready( + &self, + codecs: Vec<( + u32, + &str, + u32, + u32, + u32, + ::std::collections::HashMap<&str, &str>, + )>, + ) -> Result<(), tree::MethodErr>; + fn set_local_codecs( + &self, + codecs: Vec<( + u32, + &str, + u32, + u32, + u32, + ::std::collections::HashMap<&str, &str>, + )>, + ) -> Result<(), tree::MethodErr>; + fn stream_state(&self, state: u32) -> Result<(), tree::MethodErr>; + fn supported_codecs( + &self, + codecs: Vec<( + u32, + &str, + u32, + u32, + u32, + ::std::collections::HashMap<&str, &str>, + )>, + ) -> Result<(), tree::MethodErr>; + fn codecs_updated( + &self, + codecs: Vec<( + u32, + &str, + u32, + u32, + u32, + ::std::collections::HashMap<&str, &str>, + )>, + ) -> Result<(), tree::MethodErr>; + fn hold_state(&self, held: bool) -> Result<(), tree::MethodErr>; + fn unhold_failure(&self) -> Result<(), tree::MethodErr>; + fn supported_feedback_messages( + &self, + messages: ::std::collections::HashMap)>, + ) -> Result<(), tree::MethodErr>; + fn supported_header_extensions( + &self, + header_extensions: Vec<(u32, u32, &str, &str)>, + ) -> Result<(), tree::MethodErr>; + fn stunservers(&self) -> Result, tree::MethodErr>; + fn created_locally(&self) -> Result; + fn nattraversal(&self) -> Result; + fn relay_info( + &self, + ) -> Result< + Vec<::std::collections::HashMap>>>, + tree::MethodErr, + >; +} + +pub fn media_stream_handler_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + D::Signal: Default, + T: MediaStreamHandler, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface("org.freedesktop.Telepathy.Media.StreamHandler", data); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let codec_id: u32 = i.read()?; + let d = fclone(minfo); + d.codec_choice(codec_id)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("CodecChoice", Default::default(), h); + let m = m.in_arg(("Codec_ID", "u")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let error_code: u32 = i.read()?; + let message: &str = i.read()?; + let d = fclone(minfo); + d.error(error_code, message)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("Error", Default::default(), h); + let m = m.in_arg(("Error_Code", "u")); + let m = m.in_arg(("Message", "s")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let d = fclone(minfo); + d.native_candidates_prepared()?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("NativeCandidatesPrepared", Default::default(), h); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let native_candidate_id: &str = i.read()?; + let remote_candidate_id: &str = i.read()?; + let d = fclone(minfo); + d.new_active_candidate_pair(native_candidate_id, remote_candidate_id)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("NewActiveCandidatePair", Default::default(), h); + let m = m.in_arg(("Native_Candidate_ID", "s")); + let m = m.in_arg(("Remote_Candidate_ID", "s")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let native_candidate_id: &str = i.read()?; + let native_transport: (u32, &str, u32, u32, &str, &str, f64, u32, &str, &str) = i.read()?; + let remote_candidate_id: &str = i.read()?; + let remote_transport: (u32, &str, u32, u32, &str, &str, f64, u32, &str, &str) = i.read()?; + let d = fclone(minfo); + d.new_active_transport_pair( + native_candidate_id, + native_transport, + remote_candidate_id, + remote_transport, + )?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("NewActiveTransportPair", Default::default(), h); + let m = m.in_arg(("Native_Candidate_ID", "s")); + let m = m.in_arg(("Native_Transport", "(usuussduss)")); + let m = m.in_arg(("Remote_Candidate_ID", "s")); + let m = m.in_arg(("Remote_Transport", "(usuussduss)")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let candidate_id: &str = i.read()?; + let transports: Vec<(u32, &str, u32, u32, &str, &str, f64, u32, &str, &str)> = i.read()?; + let d = fclone(minfo); + d.new_native_candidate(candidate_id, transports)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("NewNativeCandidate", Default::default(), h); + let m = m.in_arg(("Candidate_ID", "s")); + let m = m.in_arg(("Transports", "a(usuussduss)")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let codecs: Vec<( + u32, + &str, + u32, + u32, + u32, + ::std::collections::HashMap<&str, &str>, + )> = i.read()?; + let d = fclone(minfo); + d.ready(codecs)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("Ready", Default::default(), h); + let m = m.in_arg(("Codecs", "a(usuuua{ss})")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let codecs: Vec<( + u32, + &str, + u32, + u32, + u32, + ::std::collections::HashMap<&str, &str>, + )> = i.read()?; + let d = fclone(minfo); + d.set_local_codecs(codecs)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("SetLocalCodecs", Default::default(), h); + let m = m.in_arg(("Codecs", "a(usuuua{ss})")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let state: u32 = i.read()?; + let d = fclone(minfo); + d.stream_state(state)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("StreamState", Default::default(), h); + let m = m.in_arg(("State", "u")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let codecs: Vec<( + u32, + &str, + u32, + u32, + u32, + ::std::collections::HashMap<&str, &str>, + )> = i.read()?; + let d = fclone(minfo); + d.supported_codecs(codecs)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("SupportedCodecs", Default::default(), h); + let m = m.in_arg(("Codecs", "a(usuuua{ss})")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let codecs: Vec<( + u32, + &str, + u32, + u32, + u32, + ::std::collections::HashMap<&str, &str>, + )> = i.read()?; + let d = fclone(minfo); + d.codecs_updated(codecs)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("CodecsUpdated", Default::default(), h); + let m = m.in_arg(("Codecs", "a(usuuua{ss})")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let held: bool = i.read()?; + let d = fclone(minfo); + d.hold_state(held)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("HoldState", Default::default(), h); + let m = m.in_arg(("Held", "b")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let d = fclone(minfo); + d.unhold_failure()?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("UnholdFailure", Default::default(), h); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let messages: ::std::collections::HashMap)> = + i.read()?; + let d = fclone(minfo); + d.supported_feedback_messages(messages)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("SupportedFeedbackMessages", Default::default(), h); + let m = m.in_arg(("Messages", "a{u(ua(sss))}")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let header_extensions: Vec<(u32, u32, &str, &str)> = i.read()?; + let d = fclone(minfo); + d.supported_header_extensions(header_extensions)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("SupportedHeaderExtensions", Default::default(), h); + let m = m.in_arg(("Header_Extensions", "a(uuss)")); + let i = i.add_m(m); + + let p = factory.property::, _>("STUNServers", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.stunservers()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("CreatedLocally", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.created_locally()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::<&str, _>("NATTraversal", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.nattraversal()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory + .property::>>>, _>( + "RelayInfo", + Default::default(), + ); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.relay_info()?); + Ok(()) + }); + let i = i.add_p(p); + let s = factory.signal("AddRemoteCandidate", Default::default()); + let s = s.arg(("Candidate_ID", "s")); + let s = s.arg(("Transports", "a(usuussduss)")); + let i = i.add_s(s); + let s = factory.signal("Close", Default::default()); + let i = i.add_s(s); + let s = factory.signal("RemoveRemoteCandidate", Default::default()); + let s = s.arg(("Candidate_ID", "s")); + let i = i.add_s(s); + let s = factory.signal("SetActiveCandidatePair", Default::default()); + let s = s.arg(("Native_Candidate_ID", "s")); + let s = s.arg(("Remote_Candidate_ID", "s")); + let i = i.add_s(s); + let s = factory.signal("SetRemoteCandidateList", Default::default()); + let s = s.arg(("Remote_Candidates", "a(sa(usuussduss))")); + let i = i.add_s(s); + let s = factory.signal("SetRemoteCodecs", Default::default()); + let s = s.arg(("Codecs", "a(usuuua{ss})")); + let i = i.add_s(s); + let s = factory.signal("SetStreamPlaying", Default::default()); + let s = s.arg(("Playing", "b")); + let i = i.add_s(s); + let s = factory.signal("SetStreamSending", Default::default()); + let s = s.arg(("Sending", "b")); + let i = i.add_s(s); + let s = factory.signal("StartTelephonyEvent", Default::default()); + let s = s.arg(("Event", "y")); + let i = i.add_s(s); + let s = factory.signal("StartNamedTelephonyEvent", Default::default()); + let s = s.arg(("Event", "y")); + let s = s.arg(("Codec_ID", "u")); + let i = i.add_s(s); + let s = factory.signal("StartSoundTelephonyEvent", Default::default()); + let s = s.arg(("Event", "y")); + let i = i.add_s(s); + let s = factory.signal("StopTelephonyEvent", Default::default()); + let i = i.add_s(s); + let s = factory.signal("SetStreamHeld", Default::default()); + let s = s.arg(("Held", "b")); + let i = i.add_s(s); + let s = factory.signal("SetRemoteFeedbackMessages", Default::default()); + let s = s.arg(("Messages", "a{u(ua(sss))}")); + let i = i.add_s(s); + let s = factory.signal("SetRemoteHeaderExtensions", Default::default()); + let s = s.arg(("Header_Extensions", "a(uuss)")); + let i = i.add_s(s); + i +} + +#[derive(Debug)] +pub struct MediaStreamHandlerAddRemoteCandidate { + pub candidate_id: String, + pub transports: Vec<( + u32, + String, + u32, + u32, + String, + String, + f64, + u32, + String, + String, + )>, +} + +impl arg::AppendAll for MediaStreamHandlerAddRemoteCandidate { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.candidate_id, i); + arg::RefArg::append(&self.transports, i); + } +} + +impl arg::ReadAll for MediaStreamHandlerAddRemoteCandidate { + fn read(i: &mut arg::Iter) -> Result { + Ok(MediaStreamHandlerAddRemoteCandidate { + candidate_id: i.read()?, + transports: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for MediaStreamHandlerAddRemoteCandidate { + const NAME: &'static str = "AddRemoteCandidate"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Media.StreamHandler"; +} + +#[derive(Debug)] +pub struct MediaStreamHandlerClose {} + +impl arg::AppendAll for MediaStreamHandlerClose { + fn append(&self, _: &mut arg::IterAppend) {} +} + +impl arg::ReadAll for MediaStreamHandlerClose { + fn read(_: &mut arg::Iter) -> Result { + Ok(MediaStreamHandlerClose {}) + } +} + +impl dbus::message::SignalArgs for MediaStreamHandlerClose { + const NAME: &'static str = "Close"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Media.StreamHandler"; +} + +#[derive(Debug)] +pub struct MediaStreamHandlerRemoveRemoteCandidate { + pub candidate_id: String, +} + +impl arg::AppendAll for MediaStreamHandlerRemoveRemoteCandidate { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.candidate_id, i); + } +} + +impl arg::ReadAll for MediaStreamHandlerRemoveRemoteCandidate { + fn read(i: &mut arg::Iter) -> Result { + Ok(MediaStreamHandlerRemoveRemoteCandidate { + candidate_id: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for MediaStreamHandlerRemoveRemoteCandidate { + const NAME: &'static str = "RemoveRemoteCandidate"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Media.StreamHandler"; +} + +#[derive(Debug)] +pub struct MediaStreamHandlerSetActiveCandidatePair { + pub native_candidate_id: String, + pub remote_candidate_id: String, +} + +impl arg::AppendAll for MediaStreamHandlerSetActiveCandidatePair { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.native_candidate_id, i); + arg::RefArg::append(&self.remote_candidate_id, i); + } +} + +impl arg::ReadAll for MediaStreamHandlerSetActiveCandidatePair { + fn read(i: &mut arg::Iter) -> Result { + Ok(MediaStreamHandlerSetActiveCandidatePair { + native_candidate_id: i.read()?, + remote_candidate_id: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for MediaStreamHandlerSetActiveCandidatePair { + const NAME: &'static str = "SetActiveCandidatePair"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Media.StreamHandler"; +} + +#[derive(Debug)] +pub struct MediaStreamHandlerSetRemoteCandidateList { + pub remote_candidates: Vec<( + String, + Vec<( + u32, + String, + u32, + u32, + String, + String, + f64, + u32, + String, + String, + )>, + )>, +} + +impl arg::AppendAll for MediaStreamHandlerSetRemoteCandidateList { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.remote_candidates, i); + } +} + +impl arg::ReadAll for MediaStreamHandlerSetRemoteCandidateList { + fn read(i: &mut arg::Iter) -> Result { + Ok(MediaStreamHandlerSetRemoteCandidateList { + remote_candidates: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for MediaStreamHandlerSetRemoteCandidateList { + const NAME: &'static str = "SetRemoteCandidateList"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Media.StreamHandler"; +} + +#[derive(Debug)] +pub struct MediaStreamHandlerSetRemoteCodecs { + pub codecs: Vec<( + u32, + String, + u32, + u32, + u32, + ::std::collections::HashMap, + )>, +} + +impl arg::AppendAll for MediaStreamHandlerSetRemoteCodecs { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.codecs, i); + } +} + +impl arg::ReadAll for MediaStreamHandlerSetRemoteCodecs { + fn read(i: &mut arg::Iter) -> Result { + Ok(MediaStreamHandlerSetRemoteCodecs { codecs: i.read()? }) + } +} + +impl dbus::message::SignalArgs for MediaStreamHandlerSetRemoteCodecs { + const NAME: &'static str = "SetRemoteCodecs"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Media.StreamHandler"; +} + +#[derive(Debug)] +pub struct MediaStreamHandlerSetStreamPlaying { + pub playing: bool, +} + +impl arg::AppendAll for MediaStreamHandlerSetStreamPlaying { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.playing, i); + } +} + +impl arg::ReadAll for MediaStreamHandlerSetStreamPlaying { + fn read(i: &mut arg::Iter) -> Result { + Ok(MediaStreamHandlerSetStreamPlaying { playing: i.read()? }) + } +} + +impl dbus::message::SignalArgs for MediaStreamHandlerSetStreamPlaying { + const NAME: &'static str = "SetStreamPlaying"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Media.StreamHandler"; +} + +#[derive(Debug)] +pub struct MediaStreamHandlerSetStreamSending { + pub sending: bool, +} + +impl arg::AppendAll for MediaStreamHandlerSetStreamSending { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.sending, i); + } +} + +impl arg::ReadAll for MediaStreamHandlerSetStreamSending { + fn read(i: &mut arg::Iter) -> Result { + Ok(MediaStreamHandlerSetStreamSending { sending: i.read()? }) + } +} + +impl dbus::message::SignalArgs for MediaStreamHandlerSetStreamSending { + const NAME: &'static str = "SetStreamSending"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Media.StreamHandler"; +} + +#[derive(Debug)] +pub struct MediaStreamHandlerStartTelephonyEvent { + pub event: u8, +} + +impl arg::AppendAll for MediaStreamHandlerStartTelephonyEvent { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.event, i); + } +} + +impl arg::ReadAll for MediaStreamHandlerStartTelephonyEvent { + fn read(i: &mut arg::Iter) -> Result { + Ok(MediaStreamHandlerStartTelephonyEvent { event: i.read()? }) + } +} + +impl dbus::message::SignalArgs for MediaStreamHandlerStartTelephonyEvent { + const NAME: &'static str = "StartTelephonyEvent"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Media.StreamHandler"; +} + +#[derive(Debug)] +pub struct MediaStreamHandlerStartNamedTelephonyEvent { + pub event: u8, + pub codec_id: u32, +} + +impl arg::AppendAll for MediaStreamHandlerStartNamedTelephonyEvent { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.event, i); + arg::RefArg::append(&self.codec_id, i); + } +} + +impl arg::ReadAll for MediaStreamHandlerStartNamedTelephonyEvent { + fn read(i: &mut arg::Iter) -> Result { + Ok(MediaStreamHandlerStartNamedTelephonyEvent { + event: i.read()?, + codec_id: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for MediaStreamHandlerStartNamedTelephonyEvent { + const NAME: &'static str = "StartNamedTelephonyEvent"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Media.StreamHandler"; +} + +#[derive(Debug)] +pub struct MediaStreamHandlerStartSoundTelephonyEvent { + pub event: u8, +} + +impl arg::AppendAll for MediaStreamHandlerStartSoundTelephonyEvent { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.event, i); + } +} + +impl arg::ReadAll for MediaStreamHandlerStartSoundTelephonyEvent { + fn read(i: &mut arg::Iter) -> Result { + Ok(MediaStreamHandlerStartSoundTelephonyEvent { event: i.read()? }) + } +} + +impl dbus::message::SignalArgs for MediaStreamHandlerStartSoundTelephonyEvent { + const NAME: &'static str = "StartSoundTelephonyEvent"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Media.StreamHandler"; +} + +#[derive(Debug)] +pub struct MediaStreamHandlerStopTelephonyEvent {} + +impl arg::AppendAll for MediaStreamHandlerStopTelephonyEvent { + fn append(&self, _: &mut arg::IterAppend) {} +} + +impl arg::ReadAll for MediaStreamHandlerStopTelephonyEvent { + fn read(_: &mut arg::Iter) -> Result { + Ok(MediaStreamHandlerStopTelephonyEvent {}) + } +} + +impl dbus::message::SignalArgs for MediaStreamHandlerStopTelephonyEvent { + const NAME: &'static str = "StopTelephonyEvent"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Media.StreamHandler"; +} + +#[derive(Debug)] +pub struct MediaStreamHandlerSetStreamHeld { + pub held: bool, +} + +impl arg::AppendAll for MediaStreamHandlerSetStreamHeld { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.held, i); + } +} + +impl arg::ReadAll for MediaStreamHandlerSetStreamHeld { + fn read(i: &mut arg::Iter) -> Result { + Ok(MediaStreamHandlerSetStreamHeld { held: i.read()? }) + } +} + +impl dbus::message::SignalArgs for MediaStreamHandlerSetStreamHeld { + const NAME: &'static str = "SetStreamHeld"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Media.StreamHandler"; +} + +#[derive(Debug)] +pub struct MediaStreamHandlerSetRemoteFeedbackMessages { + pub messages: ::std::collections::HashMap)>, +} + +impl arg::AppendAll for MediaStreamHandlerSetRemoteFeedbackMessages { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.messages, i); + } +} + +impl arg::ReadAll for MediaStreamHandlerSetRemoteFeedbackMessages { + fn read(i: &mut arg::Iter) -> Result { + Ok(MediaStreamHandlerSetRemoteFeedbackMessages { + messages: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for MediaStreamHandlerSetRemoteFeedbackMessages { + const NAME: &'static str = "SetRemoteFeedbackMessages"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Media.StreamHandler"; +} + +#[derive(Debug)] +pub struct MediaStreamHandlerSetRemoteHeaderExtensions { + pub header_extensions: Vec<(u32, u32, String, String)>, +} + +impl arg::AppendAll for MediaStreamHandlerSetRemoteHeaderExtensions { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.header_extensions, i); + } +} + +impl arg::ReadAll for MediaStreamHandlerSetRemoteHeaderExtensions { + fn read(i: &mut arg::Iter) -> Result { + Ok(MediaStreamHandlerSetRemoteHeaderExtensions { + header_extensions: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for MediaStreamHandlerSetRemoteHeaderExtensions { + const NAME: &'static str = "SetRemoteHeaderExtensions"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Media.StreamHandler"; +} diff --git a/src/telepathy/properties_interface.rs b/src/telepathy/properties_interface.rs new file mode 100644 index 0000000..52fcd80 --- /dev/null +++ b/src/telepathy/properties_interface.rs @@ -0,0 +1,126 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Properties_Interface.xml -i org.freedesktop.Telepathy -o src/telepathy/properties_interface.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait Properties { + fn get_properties( + &self, + properties: Vec, + ) -> Result>)>, tree::MethodErr>; + fn list_properties(&self) -> Result, tree::MethodErr>; + fn set_properties( + &self, + properties: Vec<(u32, arg::Variant>)>, + ) -> Result<(), tree::MethodErr>; +} + +pub fn properties_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Signal: Default, + T: Properties, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface("org.freedesktop.Telepathy.Properties", data); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let properties: Vec = i.read()?; + let d = fclone(minfo); + let values = d.get_properties(properties)?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(values); + Ok(vec![rm]) + }; + let m = factory.method("GetProperties", Default::default(), h); + let m = m.in_arg(("Properties", "au")); + let m = m.out_arg(("Values", "a(uv)")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let d = fclone(minfo); + let available_properties = d.list_properties()?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(available_properties); + Ok(vec![rm]) + }; + let m = factory.method("ListProperties", Default::default(), h); + let m = m.out_arg(("Available_Properties", "a(ussu)")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let properties: Vec<(u32, arg::Variant>)> = i.read()?; + let d = fclone(minfo); + d.set_properties(properties)?; + let rm = minfo.msg.method_return(); + Ok(vec![rm]) + }; + let m = factory.method("SetProperties", Default::default(), h); + let m = m.in_arg(("Properties", "a(uv)")); + let i = i.add_m(m); + let s = factory.signal("PropertiesChanged", Default::default()); + let s = s.arg(("Properties", "a(uv)")); + let i = i.add_s(s); + let s = factory.signal("PropertyFlagsChanged", Default::default()); + let s = s.arg(("Properties", "a(uu)")); + let i = i.add_s(s); + i +} + +#[derive(Debug)] +pub struct PropertiesPropertiesChanged { + pub properties: Vec<(u32, arg::Variant>)>, +} + +impl arg::AppendAll for PropertiesPropertiesChanged { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.properties, i); + } +} + +impl arg::ReadAll for PropertiesPropertiesChanged { + fn read(i: &mut arg::Iter) -> Result { + Ok(PropertiesPropertiesChanged { + properties: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for PropertiesPropertiesChanged { + const NAME: &'static str = "PropertiesChanged"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Properties"; +} + +#[derive(Debug)] +pub struct PropertiesPropertyFlagsChanged { + pub properties: Vec<(u32, u32)>, +} + +impl arg::AppendAll for PropertiesPropertyFlagsChanged { + fn append(&self, i: &mut arg::IterAppend) { + arg::RefArg::append(&self.properties, i); + } +} + +impl arg::ReadAll for PropertiesPropertyFlagsChanged { + fn read(i: &mut arg::Iter) -> Result { + Ok(PropertiesPropertyFlagsChanged { + properties: i.read()?, + }) + } +} + +impl dbus::message::SignalArgs for PropertiesPropertyFlagsChanged { + const NAME: &'static str = "PropertyFlagsChanged"; + const INTERFACE: &'static str = "org.freedesktop.Telepathy.Properties"; +} diff --git a/src/telepathy/protocol.rs b/src/telepathy/protocol.rs new file mode 100644 index 0000000..891c8df --- /dev/null +++ b/src/telepathy/protocol.rs @@ -0,0 +1,179 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Protocol.xml -i org.freedesktop.Telepathy -o src/telepathy/protocol.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait Protocol { + fn identify_account( + &self, + parameters: ::std::collections::HashMap<&str, arg::Variant>>, + ) -> Result; + fn normalize_contact(&self, contact_id: &str) -> Result; + fn interfaces(&self) -> Result, tree::MethodErr>; + fn parameters( + &self, + ) -> Result< + Vec<( + String, + u32, + String, + arg::Variant>, + )>, + tree::MethodErr, + >; + fn connection_interfaces(&self) -> Result, tree::MethodErr>; + fn requestable_channel_classes( + &self, + ) -> Result< + Vec<( + ::std::collections::HashMap>>, + Vec, + )>, + tree::MethodErr, + >; + fn vcard_field(&self) -> Result; + fn english_name(&self) -> Result; + fn icon(&self) -> Result; + fn authentication_types(&self) -> Result, tree::MethodErr>; +} + +pub fn protocol_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + T: Protocol, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface("org.freedesktop.Telepathy.Protocol", data); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let parameters: ::std::collections::HashMap<&str, arg::Variant>> = + i.read()?; + let d = fclone(minfo); + let account_id = d.identify_account(parameters)?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(account_id); + Ok(vec![rm]) + }; + let m = factory.method("IdentifyAccount", Default::default(), h); + let m = m.in_arg(("Parameters", "a{sv}")); + let m = m.out_arg(("Account_ID", "s")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let contact_id: &str = i.read()?; + let d = fclone(minfo); + let normalized_contact_id = d.normalize_contact(contact_id)?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(normalized_contact_id); + Ok(vec![rm]) + }; + let m = factory.method("NormalizeContact", Default::default(), h); + let m = m.in_arg(("Contact_ID", "s")); + let m = m.out_arg(("Normalized_Contact_ID", "s")); + let i = i.add_m(m); + + let p = factory.property::, _>("Interfaces", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.interfaces()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::>)>, _>( + "Parameters", + Default::default(), + ); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.parameters()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::, _>("ConnectionInterfaces", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.connection_interfaces()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::>>, + Vec<&str>, + )>, _>("RequestableChannelClasses", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.requestable_channel_classes()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::<&str, _>("VCardField", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.vcard_field()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::<&str, _>("EnglishName", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.english_name()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::<&str, _>("Icon", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.icon()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::, _>("AuthenticationTypes", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.authentication_types()?); + Ok(()) + }); + let i = i.add_p(p); + i +} diff --git a/src/telepathy/protocol_interface_addressing.rs b/src/telepathy/protocol_interface_addressing.rs new file mode 100644 index 0000000..7e08cd2 --- /dev/null +++ b/src/telepathy/protocol_interface_addressing.rs @@ -0,0 +1,88 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Protocol_Interface_Addressing.xml -i org.freedesktop.Telepathy -o src/telepathy/protocol_interface_addressing.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ProtocolInterfaceAddressing { + fn normalize_vcard_address( + &self, + vcard_field: &str, + vcard_address: &str, + ) -> Result; + fn normalize_contact_uri(&self, uri: &str) -> Result; + fn addressable_vcard_fields(&self) -> Result, tree::MethodErr>; + fn addressable_urischemes(&self) -> Result, tree::MethodErr>; +} + +pub fn protocol_interface_addressing_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + T: ProtocolInterfaceAddressing, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface( + "org.freedesktop.Telepathy.Protocol.Interface.Addressing", + data, + ); + let f = ::std::sync::Arc::new(f); + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let vcard_field: &str = i.read()?; + let vcard_address: &str = i.read()?; + let d = fclone(minfo); + let normalized_vcard_address = d.normalize_vcard_address(vcard_field, vcard_address)?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(normalized_vcard_address); + Ok(vec![rm]) + }; + let m = factory.method("NormalizeVCardAddress", Default::default(), h); + let m = m.in_arg(("VCard_Field", "s")); + let m = m.in_arg(("VCard_Address", "s")); + let m = m.out_arg(("Normalized_VCard_Address", "s")); + let i = i.add_m(m); + + let fclone = f.clone(); + let h = move |minfo: &tree::MethodInfo, D>| { + let mut i = minfo.msg.iter_init(); + let uri: &str = i.read()?; + let d = fclone(minfo); + let normalized_uri = d.normalize_contact_uri(uri)?; + let rm = minfo.msg.method_return(); + let rm = rm.append1(normalized_uri); + Ok(vec![rm]) + }; + let m = factory.method("NormalizeContactURI", Default::default(), h); + let m = m.in_arg(("URI", "s")); + let m = m.out_arg(("Normalized_URI", "s")); + let i = i.add_m(m); + + let p = factory.property::, _>("AddressableVCardFields", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.addressable_vcard_fields()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::, _>("AddressableURISchemes", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.addressable_urischemes()?); + Ok(()) + }); + let i = i.add_p(p); + i +} diff --git a/src/telepathy/protocol_interface_avatars.rs b/src/telepathy/protocol_interface_avatars.rs new file mode 100644 index 0000000..873d887 --- /dev/null +++ b/src/telepathy/protocol_interface_avatars.rs @@ -0,0 +1,119 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Protocol_Interface_Avatars.xml -i org.freedesktop.Telepathy -o src/telepathy/protocol_interface_avatars.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ProtocolInterfaceAvatars { + fn supported_avatar_mimetypes(&self) -> Result, tree::MethodErr>; + fn minimum_avatar_height(&self) -> Result; + fn minimum_avatar_width(&self) -> Result; + fn recommended_avatar_height(&self) -> Result; + fn recommended_avatar_width(&self) -> Result; + fn maximum_avatar_height(&self) -> Result; + fn maximum_avatar_width(&self) -> Result; + fn maximum_avatar_bytes(&self) -> Result; +} + +pub fn protocol_interface_avatars_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + T: ProtocolInterfaceAvatars, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface("org.freedesktop.Telepathy.Protocol.Interface.Avatars", data); + let f = ::std::sync::Arc::new(f); + let p = factory.property::, _>("SupportedAvatarMIMETypes", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.supported_avatar_mimetypes()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("MinimumAvatarHeight", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.minimum_avatar_height()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("MinimumAvatarWidth", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.minimum_avatar_width()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("RecommendedAvatarHeight", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.recommended_avatar_height()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("RecommendedAvatarWidth", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.recommended_avatar_width()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("MaximumAvatarHeight", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.maximum_avatar_height()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("MaximumAvatarWidth", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.maximum_avatar_width()?); + Ok(()) + }); + let i = i.add_p(p); + + let p = factory.property::("MaximumAvatarBytes", Default::default()); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.maximum_avatar_bytes()?); + Ok(()) + }); + let i = i.add_p(p); + i +} diff --git a/src/telepathy/protocol_interface_presence.rs b/src/telepathy/protocol_interface_presence.rs new file mode 100644 index 0000000..3965cc1 --- /dev/null +++ b/src/telepathy/protocol_interface_presence.rs @@ -0,0 +1,43 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Protocol_Interface_Presence.xml -i org.freedesktop.Telepathy -o src/telepathy/protocol_interface_presence.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait ProtocolInterfacePresence { + fn statuses( + &self, + ) -> Result<::std::collections::HashMap, tree::MethodErr>; +} + +pub fn protocol_interface_presence_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + T: ProtocolInterfacePresence, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface( + "org.freedesktop.Telepathy.Protocol.Interface.Presence", + data, + ); + let f = ::std::sync::Arc::new(f); + let p = factory.property::<::std::collections::HashMap<&str, (u32, bool, bool)>, _>( + "Statuses", + Default::default(), + ); + let p = p.access(tree::Access::Read); + let fclone = f.clone(); + let p = p.on_get(move |a, pinfo| { + let minfo = pinfo.to_method_info(); + let d = fclone(&minfo); + a.append(d.statuses()?); + Ok(()) + }); + let i = i.add_p(p); + i +} diff --git a/src/telepathy/template.rs b/src/telepathy/template.rs new file mode 100644 index 0000000..bf14278 --- /dev/null +++ b/src/telepathy/template.rs @@ -0,0 +1,22 @@ +// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/template.xml -i org.freedesktop.Telepathy -o src/telepathy/template.rs`, see https://github.com/diwic/dbus-rs +use dbus; +use dbus::arg; +use dbus::tree; + +pub trait FooDRAFT {} + +pub fn foo_draft_server( + factory: &tree::Factory, D>, + data: D::Interface, + f: F, +) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + T: FooDRAFT, + F: 'static + for<'z> Fn(&'z tree::MethodInfo, D>) -> &'z T, +{ + let i = factory.interface("org.freedesktop.Telepathy.Foo.DRAFT", data); + let f = ::std::sync::Arc::new(f); + i +}