// This code was autogenerated with `dbus-codegen-rust --file telepathy-spec/spec/Call_Stream_Interface_Media.xml -i org.freedesktop.Telepathy -a AsRefClosure -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<Box<dyn arg::RefArg>>>,
        )>,
    ) -> 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<u32, tree::MethodErr>;
    fn receiving_state(&self) -> Result<u32, tree::MethodErr>;
    fn transport(&self) -> Result<u32, tree::MethodErr>;
    fn local_candidates(
        &self,
    ) -> Result<
        Vec<(
            u32,
            String,
            u32,
            ::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
        )>,
        tree::MethodErr,
    >;
    fn local_credentials(&self) -> Result<(String, String), tree::MethodErr>;
    fn stunservers(&self) -> Result<Vec<(String, u16)>, tree::MethodErr>;
    fn relay_info(
        &self,
    ) -> Result<
        Vec<::std::collections::HashMap<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>>,
        tree::MethodErr,
    >;
    fn has_server_info(&self) -> Result<bool, tree::MethodErr>;
    fn endpoints(&self) -> Result<Vec<dbus::Path<'static>>, tree::MethodErr>;
    fn icerestart_pending(&self) -> Result<bool, tree::MethodErr>;
}

pub fn call1_stream_interface_media_server<F, T, D>(
    factory: &tree::Factory<tree::MTFn<D>, D>,
    data: D::Interface,
    f: F,
) -> tree::Interface<tree::MTFn<D>, D>
where
    D: tree::DataType,
    D::Method: Default,
    D::Property: Default,
    D::Signal: Default,
    T: AsRef<dyn Call1StreamInterfaceMedia>,
    F: 'static + Fn(&tree::MethodInfo<tree::MTFn<D>, D>) -> 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<tree::MTFn<D>, D>| {
        let mut i = minfo.msg.iter_init();
        let state: u32 = i.read()?;
        let dd = fclone(minfo);
        let d = dd.as_ref();
        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<tree::MTFn<D>, D>| {
        let mut i = minfo.msg.iter_init();
        let reason: u32 = i.read()?;
        let error: &str = i.read()?;
        let message: &str = i.read()?;
        let dd = fclone(minfo);
        let d = dd.as_ref();
        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<tree::MTFn<D>, D>| {
        let mut i = minfo.msg.iter_init();
        let state: u32 = i.read()?;
        let dd = fclone(minfo);
        let d = dd.as_ref();
        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<tree::MTFn<D>, D>| {
        let mut i = minfo.msg.iter_init();
        let reason: u32 = i.read()?;
        let error: &str = i.read()?;
        let message: &str = i.read()?;
        let dd = fclone(minfo);
        let d = dd.as_ref();
        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<tree::MTFn<D>, D>| {
        let mut i = minfo.msg.iter_init();
        let username: &str = i.read()?;
        let password: &str = i.read()?;
        let dd = fclone(minfo);
        let d = dd.as_ref();
        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<tree::MTFn<D>, D>| {
        let mut i = minfo.msg.iter_init();
        let candidates: Vec<(
            u32,
            &str,
            u32,
            ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
        )> = i.read()?;
        let dd = fclone(minfo);
        let d = dd.as_ref();
        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<tree::MTFn<D>, D>| {
        let dd = fclone(minfo);
        let d = dd.as_ref();
        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<tree::MTFn<D>, D>| {
        let mut i = minfo.msg.iter_init();
        let reason: (u32, u32, &str, &str) = i.read()?;
        let dd = fclone(minfo);
        let d = dd.as_ref();
        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::<u32, _>("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 dd = fclone(&minfo);
        let d = dd.as_ref();
        a.append(d.sending_state()?);
        Ok(())
    });
    let i = i.add_p(p);

    let p = factory.property::<u32, _>("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 dd = fclone(&minfo);
        let d = dd.as_ref();
        a.append(d.receiving_state()?);
        Ok(())
    });
    let i = i.add_p(p);

    let p = factory.property::<u32, _>("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 dd = fclone(&minfo);
        let d = dd.as_ref();
        a.append(d.transport()?);
        Ok(())
    });
    let i = i.add_p(p);

    let p = factory.property::<Vec<(
        u32,
        &str,
        u32,
        ::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>,
    )>, _>("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 dd = fclone(&minfo);
        let d = dd.as_ref();
        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 dd = fclone(&minfo);
        let d = dd.as_ref();
        a.append(d.local_credentials()?);
        Ok(())
    });
    let i = i.add_p(p);

    let p = factory.property::<Vec<(&str, u16)>, _>("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 dd = fclone(&minfo);
        let d = dd.as_ref();
        a.append(d.stunservers()?);
        Ok(())
    });
    let i = i.add_p(p);

    let p = factory
        .property::<Vec<::std::collections::HashMap<&str, arg::Variant<Box<dyn arg::RefArg>>>>, _>(
            "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 dd = fclone(&minfo);
        let d = dd.as_ref();
        a.append(d.relay_info()?);
        Ok(())
    });
    let i = i.add_p(p);

    let p = factory.property::<bool, _>("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 dd = fclone(&minfo);
        let d = dd.as_ref();
        a.append(d.has_server_info()?);
        Ok(())
    });
    let i = i.add_p(p);

    let p = factory.property::<Vec<dbus::Path>, _>("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 dd = fclone(&minfo);
        let d = dd.as_ref();
        a.append(d.endpoints()?);
        Ok(())
    });
    let i = i.add_p(p);

    let p = factory.property::<bool, _>("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 dd = fclone(&minfo);
        let d = dd.as_ref();
        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<Self, arg::TypeMismatchError> {
        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<Self, arg::TypeMismatchError> {
        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<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>,
    )>,
}

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<Self, arg::TypeMismatchError> {
        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<Self, arg::TypeMismatchError> {
        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<String, arg::Variant<Box<dyn arg::RefArg + 'static>>>>,
}

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<Self, arg::TypeMismatchError> {
        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<Self, arg::TypeMismatchError> {
        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<Self, arg::TypeMismatchError> {
        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<dbus::Path<'static>>,
    pub endpoints_removed: Vec<dbus::Path<'static>>,
}

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<Self, arg::TypeMismatchError> {
        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<Self, arg::TypeMismatchError> {
        Ok(Call1StreamInterfaceMediaICERestartRequested {})
    }
}

impl dbus::message::SignalArgs for Call1StreamInterfaceMediaICERestartRequested {
    const NAME: &'static str = "ICERestartRequested";
    const INTERFACE: &'static str = "org.freedesktop.Telepathy.Call1.Stream.Interface.Media";
}