gio/auto/

dbus_connection.rs

// This file was generated by gir (https://github.com/gtk-rs/gir)
// from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT
#![allow(deprecated)]

#[cfg(unix)]
#[cfg_attr(docsrs, doc(cfg(unix)))]
use crate::UnixFDList;
use crate::{
    AsyncInitable, AsyncResult, Cancellable, Credentials, DBusAuthObserver, DBusCallFlags,
    DBusCapabilityFlags, DBusConnectionFlags, DBusMessage, DBusSendMessageFlags, IOStream,
    Initable, ffi,
};
use glib::{
    object::ObjectType as _,
    prelude::*,
    signal::{SignalHandlerId, connect_raw},
    translate::*,
};
use std::{boxed::Box as Box_, pin::Pin};

glib::wrapper! {
    /// The `GDBusConnection` type is used for D-Bus connections to remote
    /// peers such as a message buses.
    ///
    /// It is a low-level API that offers a lot of flexibility. For instance,
    /// it lets you establish a connection over any transport that can by represented
    /// as a [`IOStream`][crate::IOStream].
    ///
    /// This class is rarely used directly in D-Bus clients. If you are writing
    /// a D-Bus client, it is often easier to use the `bus_own_name()`,
    /// `bus_watch_name()` or [`DBusProxy::for_bus()`][crate::DBusProxy::for_bus()] APIs.
    ///
    /// As an exception to the usual GLib rule that a particular object must not
    /// be used by two threads at the same time, `GDBusConnection`s methods may be
    /// called from any thread. This is so that [`bus_get()`][crate::bus_get()] and
    /// [`bus_get_sync()`][crate::bus_get_sync()] can safely return the same `GDBusConnection` when
    /// called from any thread.
    ///
    /// Most of the ways to obtain a `GDBusConnection` automatically initialize it
    /// (i.e. connect to D-Bus): for instance, [`new()`][Self::new()] and
    /// [`bus_get()`][crate::bus_get()], and the synchronous versions of those methods, give you
    /// an initialized connection. Language bindings for GIO should use
    /// [`Initable::new()`][crate::Initable::new()] or [`AsyncInitable::new_async()`][crate::AsyncInitable::new_async()], which also
    /// initialize the connection.
    ///
    /// If you construct an uninitialized `GDBusConnection`, such as via
    /// [`glib::Object::new()`][crate::glib::Object::new()], you must initialize it via [`InitableExt::init()`][crate::prelude::InitableExt::init()] or
    /// [`AsyncInitableExt::init_async()`][crate::prelude::AsyncInitableExt::init_async()] before using its methods or properties.
    /// Calling methods or accessing properties on a `GDBusConnection` that has not
    /// completed initialization successfully is considered to be invalid, and leads
    /// to undefined behaviour. In particular, if initialization fails with a
    /// `GError`, the only valid thing you can do with that `GDBusConnection` is to
    /// free it with `GObject::Object::unref()`.
    ///
    /// ## An example D-Bus server
    ///
    /// Here is an example for a D-Bus server:
    /// [gdbus-example-server.c](https://gitlab.gnome.org/GNOME/glib/-/blob/HEAD/gio/tests/gdbus-example-server.c)
    ///
    /// ## An example for exporting a subtree
    ///
    /// Here is an example for exporting a subtree:
    /// [gdbus-example-subtree.c](https://gitlab.gnome.org/GNOME/glib/-/blob/HEAD/gio/tests/gdbus-example-subtree.c)
    ///
    /// ## An example for file descriptor passing
    ///
    /// Here is an example for passing UNIX file descriptors:
    /// [gdbus-unix-fd-client.c](https://gitlab.gnome.org/GNOME/glib/-/blob/HEAD/gio/tests/gdbus-example-unix-fd-client.c)
    ///
    /// ## An example for exporting a GObject
    ///
    /// Here is an example for exporting a #GObject:
    /// [gdbus-example-export.c](https://gitlab.gnome.org/GNOME/glib/-/blob/HEAD/gio/tests/gdbus-example-export.c)
    ///
    /// ## Properties
    ///
    ///
    /// #### `address`
    ///  A D-Bus address specifying potential endpoints that can be used
    /// when establishing the connection.
    ///
    /// Writable | Construct Only
    ///
    ///
    /// #### `authentication-observer`
    ///  A #GDBusAuthObserver object to assist in the authentication process or [`None`].
    ///
    /// Writable | Construct Only
    ///
    ///
    /// #### `capabilities`
    ///  Flags from the #GDBusCapabilityFlags enumeration
    /// representing connection features negotiated with the other peer.
    ///
    /// Readable
    ///
    ///
    /// #### `closed`
    ///  A boolean specifying whether the connection has been closed.
    ///
    /// Readable
    ///
    ///
    /// #### `exit-on-close`
    ///  A boolean specifying whether the process will be terminated (by
    /// calling `raise(SIGTERM)`) if the connection is closed by the
    /// remote peer.
    ///
    /// Note that #GDBusConnection objects returned by g_bus_get_finish()
    /// and g_bus_get_sync() will (usually) have this property set to [`true`].
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `flags`
    ///  Flags from the #GDBusConnectionFlags enumeration.
    ///
    /// Readable | Writable | Construct Only
    ///
    ///
    /// #### `guid`
    ///  The GUID of the peer performing the role of server when
    /// authenticating.
    ///
    /// If you are constructing a #GDBusConnection and pass
    /// [`DBusConnectionFlags::AUTHENTICATION_SERVER`][crate::DBusConnectionFlags::AUTHENTICATION_SERVER] in the
    /// #GDBusConnection:flags property then you **must** also set this
    /// property to a valid guid.
    ///
    /// If you are constructing a #GDBusConnection and pass
    /// [`DBusConnectionFlags::AUTHENTICATION_CLIENT`][crate::DBusConnectionFlags::AUTHENTICATION_CLIENT] in the
    /// #GDBusConnection:flags property you will be able to read the GUID
    /// of the other peer here after the connection has been successfully
    /// initialized.
    ///
    /// Note that the
    /// [D-Bus specification](https://dbus.freedesktop.org/doc/dbus-specification.html#addresses)
    /// uses the term ‘UUID’ to refer to this, whereas GLib consistently uses the
    /// term ‘GUID’ for historical reasons.
    ///
    /// Despite its name, the format of #GDBusConnection:guid does not follow
    /// [RFC 4122](https://datatracker.ietf.org/doc/html/rfc4122) or the Microsoft
    /// GUID format.
    ///
    /// Readable | Writable | Construct Only
    ///
    ///
    /// #### `stream`
    ///  The underlying #GIOStream used for I/O.
    ///
    /// If this is passed on construction and is a #GSocketConnection,
    /// then the corresponding #GSocket will be put into non-blocking mode.
    ///
    /// While the #GDBusConnection is active, it will interact with this
    /// stream from a worker thread, so it is not safe to interact with
    /// the stream directly.
    ///
    /// Readable | Writable | Construct Only
    ///
    ///
    /// #### `unique-name`
    ///  The unique name as assigned by the message bus or [`None`] if the
    /// connection is not open or not a message bus connection.
    ///
    /// Readable
    ///
    /// ## Signals
    ///
    ///
    /// #### `closed`
    ///  Emitted when the connection is closed.
    ///
    /// The cause of this event can be
    ///
    /// - If g_dbus_connection_close() is called. In this case
    ///   @remote_peer_vanished is set to [`false`] and @error is [`None`].
    ///
    /// - If the remote peer closes the connection. In this case
    ///   @remote_peer_vanished is set to [`true`] and @error is set.
    ///
    /// - If the remote peer sends invalid or malformed data. In this
    ///   case @remote_peer_vanished is set to [`false`] and @error is set.
    ///
    /// Upon receiving this signal, you should give up your reference to
    /// @connection. You are guaranteed that this signal is emitted only
    /// once.
    ///
    ///
    ///
    /// # Implements
    ///
    /// [`trait@glib::ObjectExt`], [`AsyncInitableExt`][trait@crate::prelude::AsyncInitableExt], [`InitableExt`][trait@crate::prelude::InitableExt]
    #[doc(alias = "GDBusConnection")]
    pub struct DBusConnection(Object<ffi::GDBusConnection>) @implements AsyncInitable, Initable;

    match fn {
        type_ => || ffi::g_dbus_connection_get_type(),
    }
}

impl DBusConnection {
    /// Synchronously connects and sets up a D-Bus client connection for
    /// exchanging D-Bus messages with an endpoint specified by @address
    /// which must be in the
    /// [D-Bus address format](https://dbus.freedesktop.org/doc/dbus-specification.html#addresses).
    ///
    /// This constructor can only be used to initiate client-side
    /// connections - use g_dbus_connection_new_sync() if you need to act
    /// as the server. In particular, @flags cannot contain the
    /// [`DBusConnectionFlags::AUTHENTICATION_SERVER`][crate::DBusConnectionFlags::AUTHENTICATION_SERVER],
    /// [`DBusConnectionFlags::AUTHENTICATION_ALLOW_ANONYMOUS`][crate::DBusConnectionFlags::AUTHENTICATION_ALLOW_ANONYMOUS] or
    /// [`DBusConnectionFlags::AUTHENTICATION_REQUIRE_SAME_USER`][crate::DBusConnectionFlags::AUTHENTICATION_REQUIRE_SAME_USER] flags.
    ///
    /// This is a synchronous failable constructor. See
    /// g_dbus_connection_new_for_address() for the asynchronous version.
    ///
    /// If @observer is not [`None`] it may be used to control the
    /// authentication process.
    /// ## `address`
    /// a D-Bus address
    /// ## `flags`
    /// flags describing how to make the connection
    /// ## `observer`
    /// a #GDBusAuthObserver or [`None`]
    /// ## `cancellable`
    /// a #GCancellable or [`None`]
    ///
    /// # Returns
    ///
    /// a #GDBusConnection or [`None`] if @error is set.
    ///     Free with g_object_unref().
    #[doc(alias = "g_dbus_connection_new_for_address_sync")]
    #[doc(alias = "new_for_address_sync")]
    pub fn for_address_sync(
        address: &str,
        flags: DBusConnectionFlags,
        observer: Option<&DBusAuthObserver>,
        cancellable: Option<&impl IsA<Cancellable>>,
    ) -> Result<DBusConnection, glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::g_dbus_connection_new_for_address_sync(
                address.to_glib_none().0,
                flags.into_glib(),
                observer.to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Synchronously sets up a D-Bus connection for exchanging D-Bus messages
    /// with the end represented by @stream.
    ///
    /// If @stream is a #GSocketConnection, then the corresponding #GSocket
    /// will be put into non-blocking mode.
    ///
    /// The D-Bus connection will interact with @stream from a worker thread.
    /// As a result, the caller should not interact with @stream after this
    /// method has been called, except by calling g_object_unref() on it.
    ///
    /// If @observer is not [`None`] it may be used to control the
    /// authentication process.
    ///
    /// This is a synchronous failable constructor. See
    /// g_dbus_connection_new() for the asynchronous version.
    /// ## `stream`
    /// a #GIOStream
    /// ## `guid`
    /// the GUID to use if authenticating as a server or [`None`]
    /// ## `flags`
    /// flags describing how to make the connection
    /// ## `observer`
    /// a #GDBusAuthObserver or [`None`]
    /// ## `cancellable`
    /// a #GCancellable or [`None`]
    ///
    /// # Returns
    ///
    /// a #GDBusConnection or [`None`] if @error is set.
    ///     Free with g_object_unref().
    #[doc(alias = "g_dbus_connection_new_sync")]
    pub fn new_sync(
        stream: &impl IsA<IOStream>,
        guid: Option<&str>,
        flags: DBusConnectionFlags,
        observer: Option<&DBusAuthObserver>,
        cancellable: Option<&impl IsA<Cancellable>>,
    ) -> Result<DBusConnection, glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::g_dbus_connection_new_sync(
                stream.as_ref().to_glib_none().0,
                guid.to_glib_none().0,
                flags.into_glib(),
                observer.to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    ///
    ///  g_dbus_connection_call (connection,
    ///                          "org.freedesktop.StringThings",
    ///                          "/org/freedesktop/StringThings",
    ///                          "org.freedesktop.StringThings",
    ///                          "TwoStrings",
    ///                          g_variant_new ("(ss)",
    ///                                         "Thing One",
    ///                                         "Thing Two"),
    ///                          NULL,
    ///                          G_DBUS_CALL_FLAGS_NONE,
    ///                          -1,
    ///                          NULL,
    ///                          (GAsyncReadyCallback) two_strings_done,
    ///                          NULL);
    /// ]|
    ///
    /// This is an asynchronous method. When the operation is finished,
    /// @callback will be invoked in the thread-default main context
    /// (see [`glib::MainContext::push_thread_default()`][crate::glib::MainContext::push_thread_default()])
    /// of the thread you are calling this method from. You can then call
    /// g_dbus_connection_call_finish() to get the result of the operation.
    /// See g_dbus_connection_call_sync() for the synchronous version of this
    /// function.
    ///
    /// If @callback is [`None`] then the D-Bus method call message will be sent with
    /// the [`DBusMessageFlags::NO_REPLY_EXPECTED`][crate::DBusMessageFlags::NO_REPLY_EXPECTED] flag set.
    /// ## `bus_name`
    /// a unique or well-known bus name or [`None`] if
    ///     @self is not a message bus connection
    /// ## `object_path`
    /// path of remote object
    /// ## `interface_name`
    /// D-Bus interface to invoke method on
    /// ## `method_name`
    /// the name of the method to invoke
    /// ## `parameters`
    /// a #GVariant tuple with parameters for the method
    ///     or [`None`] if not passing parameters
    /// ## `reply_type`
    /// the expected type of the reply (which will be a
    ///     tuple), or [`None`]
    /// ## `flags`
    /// flags from the #GDBusCallFlags enumeration
    /// ## `timeout_msec`
    /// the timeout in milliseconds, -1 to use the default
    ///     timeout or `G_MAXINT` for no timeout
    /// ## `cancellable`
    /// a #GCancellable or [`None`]
    /// ## `callback`
    /// a #GAsyncReadyCallback to call when the request
    ///     is satisfied or [`None`] if you don't care about the result of the
    ///     method invocation
    #[doc(alias = "g_dbus_connection_call")]
    pub fn call<P: FnOnce(Result<glib::Variant, glib::Error>) + 'static>(
        &self,
        bus_name: Option<&str>,
        object_path: &str,
        interface_name: &str,
        method_name: &str,
        parameters: Option<&glib::Variant>,
        reply_type: Option<&glib::VariantTy>,
        flags: DBusCallFlags,
        timeout_msec: i32,
        cancellable: Option<&impl IsA<Cancellable>>,
        callback: P,
    ) {
        let main_context = glib::MainContext::ref_thread_default();
        let is_main_context_owner = main_context.is_owner();
        let has_acquired_main_context = (!is_main_context_owner)
            .then(|| main_context.acquire().ok())
            .flatten();
        assert!(
            is_main_context_owner || has_acquired_main_context.is_some(),
            "Async operations only allowed if the thread is owning the MainContext"
        );

        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
        unsafe extern "C" fn call_trampoline<
            P: FnOnce(Result<glib::Variant, glib::Error>) + 'static,
        >(
            _source_object: *mut glib::gobject_ffi::GObject,
            res: *mut crate::ffi::GAsyncResult,
            user_data: glib::ffi::gpointer,
        ) {
            unsafe {
                let mut error = std::ptr::null_mut();
                let ret =
                    ffi::g_dbus_connection_call_finish(_source_object as *mut _, res, &mut error);
                let result = if error.is_null() {
                    Ok(from_glib_full(ret))
                } else {
                    Err(from_glib_full(error))
                };
                let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
                    Box_::from_raw(user_data as *mut _);
                let callback: P = callback.into_inner();
                callback(result);
            }
        }
        let callback = call_trampoline::<P>;
        unsafe {
            ffi::g_dbus_connection_call(
                self.to_glib_none().0,
                bus_name.to_glib_none().0,
                object_path.to_glib_none().0,
                interface_name.to_glib_none().0,
                method_name.to_glib_none().0,
                parameters.to_glib_none().0,
                reply_type.to_glib_none().0,
                flags.into_glib(),
                timeout_msec,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    pub fn call_future(
        &self,
        bus_name: Option<&str>,
        object_path: &str,
        interface_name: &str,
        method_name: &str,
        parameters: Option<&glib::Variant>,
        reply_type: Option<&glib::VariantTy>,
        flags: DBusCallFlags,
        timeout_msec: i32,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<glib::Variant, glib::Error>> + 'static>>
    {
        let bus_name = bus_name.map(ToOwned::to_owned);
        let object_path = String::from(object_path);
        let interface_name = String::from(interface_name);
        let method_name = String::from(method_name);
        let parameters = parameters.map(ToOwned::to_owned);
        let reply_type = reply_type.map(ToOwned::to_owned);
        Box_::pin(crate::GioFuture::new(
            self,
            move |obj, cancellable, send| {
                obj.call(
                    bus_name.as_ref().map(::std::borrow::Borrow::borrow),
                    &object_path,
                    &interface_name,
                    &method_name,
                    parameters.as_ref().map(::std::borrow::Borrow::borrow),
                    reply_type.as_ref().map(::std::borrow::Borrow::borrow),
                    flags,
                    timeout_msec,
                    Some(cancellable),
                    move |res| {
                        send.resolve(res);
                    },
                );
            },
        ))
    }

    /// error);
    /// ]|
    ///
    /// The calling thread is blocked until a reply is received. See
    /// g_dbus_connection_call() for the asynchronous version of
    /// this method.
    /// ## `bus_name`
    /// a unique or well-known bus name or [`None`] if
    ///     @self is not a message bus connection
    /// ## `object_path`
    /// path of remote object
    /// ## `interface_name`
    /// D-Bus interface to invoke method on
    /// ## `method_name`
    /// the name of the method to invoke
    /// ## `parameters`
    /// a #GVariant tuple with parameters for the method
    ///     or [`None`] if not passing parameters
    /// ## `reply_type`
    /// the expected type of the reply, or [`None`]
    /// ## `flags`
    /// flags from the #GDBusCallFlags enumeration
    /// ## `timeout_msec`
    /// the timeout in milliseconds, -1 to use the default
    ///     timeout or `G_MAXINT` for no timeout
    /// ## `cancellable`
    /// a #GCancellable or [`None`]
    ///
    /// # Returns
    ///
    /// [`None`] if @error is set. Otherwise a non-floating
    ///     #GVariant tuple with return values. Free with g_variant_unref().
    #[doc(alias = "g_dbus_connection_call_sync")]
    pub fn call_sync(
        &self,
        bus_name: Option<&str>,
        object_path: &str,
        interface_name: &str,
        method_name: &str,
        parameters: Option<&glib::Variant>,
        reply_type: Option<&glib::VariantTy>,
        flags: DBusCallFlags,
        timeout_msec: i32,
        cancellable: Option<&impl IsA<Cancellable>>,
    ) -> Result<glib::Variant, glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::g_dbus_connection_call_sync(
                self.to_glib_none().0,
                bus_name.to_glib_none().0,
                object_path.to_glib_none().0,
                interface_name.to_glib_none().0,
                method_name.to_glib_none().0,
                parameters.to_glib_none().0,
                reply_type.to_glib_none().0,
                flags.into_glib(),
                timeout_msec,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Like g_dbus_connection_call() but also takes a #GUnixFDList object.
    ///
    /// The file descriptors normally correspond to `G_VARIANT_TYPE_HANDLE`
    /// values in the body of the message. For example, if a message contains
    /// two file descriptors, @fd_list would have length 2, and
    /// `g_variant_new_handle (0)` and `g_variant_new_handle (1)` would appear
    /// somewhere in the body of the message (not necessarily in that order!)
    /// to represent the file descriptors at indexes 0 and 1 respectively.
    ///
    /// When designing D-Bus APIs that are intended to be interoperable,
    /// please note that non-GDBus implementations of D-Bus can usually only
    /// access file descriptors if they are referenced in this way by a
    /// value of type `G_VARIANT_TYPE_HANDLE` in the body of the message.
    ///
    /// This method is only available on UNIX.
    /// ## `bus_name`
    /// a unique or well-known bus name or [`None`] if
    ///     @self is not a message bus connection
    /// ## `object_path`
    /// path of remote object
    /// ## `interface_name`
    /// D-Bus interface to invoke method on
    /// ## `method_name`
    /// the name of the method to invoke
    /// ## `parameters`
    /// a #GVariant tuple with parameters for the method
    ///     or [`None`] if not passing parameters
    /// ## `reply_type`
    /// the expected type of the reply, or [`None`]
    /// ## `flags`
    /// flags from the #GDBusCallFlags enumeration
    /// ## `timeout_msec`
    /// the timeout in milliseconds, -1 to use the default
    ///     timeout or `G_MAXINT` for no timeout
    /// ## `fd_list`
    /// a #GUnixFDList or [`None`]
    /// ## `cancellable`
    /// a #GCancellable or [`None`]
    /// ## `callback`
    /// a #GAsyncReadyCallback to call when the request is
    ///     satisfied or [`None`] if you don't * care about the result of the
    ///     method invocation
    #[cfg(unix)]
    #[cfg_attr(docsrs, doc(cfg(unix)))]
    #[doc(alias = "g_dbus_connection_call_with_unix_fd_list")]
    pub fn call_with_unix_fd_list<
        P: FnOnce(Result<(glib::Variant, Option<UnixFDList>), glib::Error>) + 'static,
    >(
        &self,
        bus_name: Option<&str>,
        object_path: &str,
        interface_name: &str,
        method_name: &str,
        parameters: Option<&glib::Variant>,
        reply_type: Option<&glib::VariantTy>,
        flags: DBusCallFlags,
        timeout_msec: i32,
        fd_list: Option<&impl IsA<UnixFDList>>,
        cancellable: Option<&impl IsA<Cancellable>>,
        callback: P,
    ) {
        let main_context = glib::MainContext::ref_thread_default();
        let is_main_context_owner = main_context.is_owner();
        let has_acquired_main_context = (!is_main_context_owner)
            .then(|| main_context.acquire().ok())
            .flatten();
        assert!(
            is_main_context_owner || has_acquired_main_context.is_some(),
            "Async operations only allowed if the thread is owning the MainContext"
        );

        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
        unsafe extern "C" fn call_with_unix_fd_list_trampoline<
            P: FnOnce(Result<(glib::Variant, Option<UnixFDList>), glib::Error>) + 'static,
        >(
            _source_object: *mut glib::gobject_ffi::GObject,
            res: *mut crate::ffi::GAsyncResult,
            user_data: glib::ffi::gpointer,
        ) {
            unsafe {
                let mut error = std::ptr::null_mut();
                let mut out_fd_list = std::ptr::null_mut();
                let ret = ffi::g_dbus_connection_call_with_unix_fd_list_finish(
                    _source_object as *mut _,
                    &mut out_fd_list,
                    res,
                    &mut error,
                );
                let result = if error.is_null() {
                    Ok((from_glib_full(ret), from_glib_full(out_fd_list)))
                } else {
                    Err(from_glib_full(error))
                };
                let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
                    Box_::from_raw(user_data as *mut _);
                let callback: P = callback.into_inner();
                callback(result);
            }
        }
        let callback = call_with_unix_fd_list_trampoline::<P>;
        unsafe {
            ffi::g_dbus_connection_call_with_unix_fd_list(
                self.to_glib_none().0,
                bus_name.to_glib_none().0,
                object_path.to_glib_none().0,
                interface_name.to_glib_none().0,
                method_name.to_glib_none().0,
                parameters.to_glib_none().0,
                reply_type.to_glib_none().0,
                flags.into_glib(),
                timeout_msec,
                fd_list.map(|p| p.as_ref()).to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    #[cfg(unix)]
    #[cfg_attr(docsrs, doc(cfg(unix)))]
    pub fn call_with_unix_fd_list_future(
        &self,
        bus_name: Option<&str>,
        object_path: &str,
        interface_name: &str,
        method_name: &str,
        parameters: Option<&glib::Variant>,
        reply_type: Option<&glib::VariantTy>,
        flags: DBusCallFlags,
        timeout_msec: i32,
        fd_list: Option<&(impl IsA<UnixFDList> + Clone + 'static)>,
    ) -> Pin<
        Box_<
            dyn std::future::Future<
                    Output = Result<(glib::Variant, Option<UnixFDList>), glib::Error>,
                > + 'static,
        >,
    > {
        let bus_name = bus_name.map(ToOwned::to_owned);
        let object_path = String::from(object_path);
        let interface_name = String::from(interface_name);
        let method_name = String::from(method_name);
        let parameters = parameters.map(ToOwned::to_owned);
        let reply_type = reply_type.map(ToOwned::to_owned);
        let fd_list = fd_list.map(ToOwned::to_owned);
        Box_::pin(crate::GioFuture::new(
            self,
            move |obj, cancellable, send| {
                obj.call_with_unix_fd_list(
                    bus_name.as_ref().map(::std::borrow::Borrow::borrow),
                    &object_path,
                    &interface_name,
                    &method_name,
                    parameters.as_ref().map(::std::borrow::Borrow::borrow),
                    reply_type.as_ref().map(::std::borrow::Borrow::borrow),
                    flags,
                    timeout_msec,
                    fd_list.as_ref().map(::std::borrow::Borrow::borrow),
                    Some(cancellable),
                    move |res| {
                        send.resolve(res);
                    },
                );
            },
        ))
    }

    /// Like g_dbus_connection_call_sync() but also takes and returns #GUnixFDList objects.
    /// See g_dbus_connection_call_with_unix_fd_list() and
    /// g_dbus_connection_call_with_unix_fd_list_finish() for more details.
    ///
    /// This method is only available on UNIX.
    /// ## `bus_name`
    /// a unique or well-known bus name or [`None`]
    ///     if @self is not a message bus connection
    /// ## `object_path`
    /// path of remote object
    /// ## `interface_name`
    /// D-Bus interface to invoke method on
    /// ## `method_name`
    /// the name of the method to invoke
    /// ## `parameters`
    /// a #GVariant tuple with parameters for
    ///     the method or [`None`] if not passing parameters
    /// ## `reply_type`
    /// the expected type of the reply, or [`None`]
    /// ## `flags`
    /// flags from the #GDBusCallFlags enumeration
    /// ## `timeout_msec`
    /// the timeout in milliseconds, -1 to use the default
    ///     timeout or `G_MAXINT` for no timeout
    /// ## `fd_list`
    /// a #GUnixFDList or [`None`]
    /// ## `cancellable`
    /// a #GCancellable or [`None`]
    ///
    /// # Returns
    ///
    /// [`None`] if @error is set. Otherwise a non-floating
    ///     #GVariant tuple with return values. Free with g_variant_unref().
    ///
    /// ## `out_fd_list`
    /// return location for a #GUnixFDList or [`None`]
    #[cfg(unix)]
    #[cfg_attr(docsrs, doc(cfg(unix)))]
    #[doc(alias = "g_dbus_connection_call_with_unix_fd_list_sync")]
    pub fn call_with_unix_fd_list_sync(
        &self,
        bus_name: Option<&str>,
        object_path: &str,
        interface_name: &str,
        method_name: &str,
        parameters: Option<&glib::Variant>,
        reply_type: Option<&glib::VariantTy>,
        flags: DBusCallFlags,
        timeout_msec: i32,
        fd_list: Option<&impl IsA<UnixFDList>>,
        cancellable: Option<&impl IsA<Cancellable>>,
    ) -> Result<(glib::Variant, Option<UnixFDList>), glib::Error> {
        unsafe {
            let mut out_fd_list = std::ptr::null_mut();
            let mut error = std::ptr::null_mut();
            let ret = ffi::g_dbus_connection_call_with_unix_fd_list_sync(
                self.to_glib_none().0,
                bus_name.to_glib_none().0,
                object_path.to_glib_none().0,
                interface_name.to_glib_none().0,
                method_name.to_glib_none().0,
                parameters.to_glib_none().0,
                reply_type.to_glib_none().0,
                flags.into_glib(),
                timeout_msec,
                fd_list.map(|p| p.as_ref()).to_glib_none().0,
                &mut out_fd_list,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok((from_glib_full(ret), from_glib_full(out_fd_list)))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Closes @self. Note that this never causes the process to
    /// exit (this might only happen if the other end of a shared message
    /// bus connection disconnects, see #GDBusConnection:exit-on-close).
    ///
    /// Once the connection is closed, operations such as sending a message
    /// will return with the error [`IOErrorEnum::Closed`][crate::IOErrorEnum::Closed]. Closing a connection
    /// will not automatically flush the connection so queued messages may
    /// be lost. Use g_dbus_connection_flush() if you need such guarantees.
    ///
    /// If @self is already closed, this method fails with
    /// [`IOErrorEnum::Closed`][crate::IOErrorEnum::Closed].
    ///
    /// When @self has been closed, the #GDBusConnection::closed
    /// signal is emitted in the thread-default main context
    /// (see [`glib::MainContext::push_thread_default()`][crate::glib::MainContext::push_thread_default()])
    /// of the thread that @self was constructed in.
    ///
    /// This is an asynchronous method. When the operation is finished,
    /// @callback will be invoked in the thread-default main context
    /// (see [`glib::MainContext::push_thread_default()`][crate::glib::MainContext::push_thread_default()])
    /// of the thread you are calling this method from. You can
    /// then call g_dbus_connection_close_finish() to get the result of the
    /// operation. See g_dbus_connection_close_sync() for the synchronous
    /// version.
    /// ## `cancellable`
    /// a #GCancellable or [`None`]
    /// ## `callback`
    /// a #GAsyncReadyCallback to call when the request is
    ///     satisfied or [`None`] if you don't care about the result
    #[doc(alias = "g_dbus_connection_close")]
    pub fn close<P: FnOnce(Result<(), glib::Error>) + 'static>(
        &self,
        cancellable: Option<&impl IsA<Cancellable>>,
        callback: P,
    ) {
        let main_context = glib::MainContext::ref_thread_default();
        let is_main_context_owner = main_context.is_owner();
        let has_acquired_main_context = (!is_main_context_owner)
            .then(|| main_context.acquire().ok())
            .flatten();
        assert!(
            is_main_context_owner || has_acquired_main_context.is_some(),
            "Async operations only allowed if the thread is owning the MainContext"
        );

        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
        unsafe extern "C" fn close_trampoline<P: FnOnce(Result<(), glib::Error>) + 'static>(
            _source_object: *mut glib::gobject_ffi::GObject,
            res: *mut crate::ffi::GAsyncResult,
            user_data: glib::ffi::gpointer,
        ) {
            unsafe {
                let mut error = std::ptr::null_mut();
                ffi::g_dbus_connection_close_finish(_source_object as *mut _, res, &mut error);
                let result = if error.is_null() {
                    Ok(())
                } else {
                    Err(from_glib_full(error))
                };
                let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
                    Box_::from_raw(user_data as *mut _);
                let callback: P = callback.into_inner();
                callback(result);
            }
        }
        let callback = close_trampoline::<P>;
        unsafe {
            ffi::g_dbus_connection_close(
                self.to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    pub fn close_future(
        &self,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> {
        Box_::pin(crate::GioFuture::new(
            self,
            move |obj, cancellable, send| {
                obj.close(Some(cancellable), move |res| {
                    send.resolve(res);
                });
            },
        ))
    }

    /// Synchronously closes @self. The calling thread is blocked
    /// until this is done. See g_dbus_connection_close() for the
    /// asynchronous version of this method and more details about what it
    /// does.
    /// ## `cancellable`
    /// a #GCancellable or [`None`]
    ///
    /// # Returns
    ///
    /// [`true`] if the operation succeeded, [`false`] if @error is set
    #[doc(alias = "g_dbus_connection_close_sync")]
    pub fn close_sync(
        &self,
        cancellable: Option<&impl IsA<Cancellable>>,
    ) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::g_dbus_connection_close_sync(
                self.to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Emits a signal.
    ///
    /// If the parameters GVariant is floating, it is consumed.
    ///
    /// This can only fail if @parameters is not compatible with the D-Bus protocol
    /// ([`IOErrorEnum::InvalidArgument`][crate::IOErrorEnum::InvalidArgument]), or if @self has been closed
    /// ([`IOErrorEnum::Closed`][crate::IOErrorEnum::Closed]).
    /// ## `destination_bus_name`
    /// the unique bus name for the destination
    ///     for the signal or [`None`] to emit to all listeners
    /// ## `object_path`
    /// path of remote object
    /// ## `interface_name`
    /// D-Bus interface to emit a signal on
    /// ## `signal_name`
    /// the name of the signal to emit
    /// ## `parameters`
    /// a #GVariant tuple with parameters for the signal
    ///              or [`None`] if not passing parameters
    ///
    /// # Returns
    ///
    /// [`true`] unless @error is set
    #[doc(alias = "g_dbus_connection_emit_signal")]
    pub fn emit_signal(
        &self,
        destination_bus_name: Option<&str>,
        object_path: &str,
        interface_name: &str,
        signal_name: &str,
        parameters: Option<&glib::Variant>,
    ) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::g_dbus_connection_emit_signal(
                self.to_glib_none().0,
                destination_bus_name.to_glib_none().0,
                object_path.to_glib_none().0,
                interface_name.to_glib_none().0,
                signal_name.to_glib_none().0,
                parameters.to_glib_none().0,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Asynchronously flushes @self, that is, writes all queued
    /// outgoing messages to the transport and then flushes the transport
    /// (using g_output_stream_flush_async()). This is useful in programs
    /// that want to emit a D-Bus signal and then exit immediately. Without
    /// flushing the connection, there is no guarantee that the message has
    /// been sent to the networking buffers in the OS kernel.
    ///
    /// This is an asynchronous method. When the operation is finished,
    /// @callback will be invoked in the thread-default main context
    /// (see [`glib::MainContext::push_thread_default()`][crate::glib::MainContext::push_thread_default()])
    /// of the thread you are calling this method from. You can
    /// then call g_dbus_connection_flush_finish() to get the result of the
    /// operation. See g_dbus_connection_flush_sync() for the synchronous
    /// version.
    /// ## `cancellable`
    /// a #GCancellable or [`None`]
    /// ## `callback`
    /// a #GAsyncReadyCallback to call when the
    ///     request is satisfied or [`None`] if you don't care about the result
    #[doc(alias = "g_dbus_connection_flush")]
    pub fn flush<P: FnOnce(Result<(), glib::Error>) + 'static>(
        &self,
        cancellable: Option<&impl IsA<Cancellable>>,
        callback: P,
    ) {
        let main_context = glib::MainContext::ref_thread_default();
        let is_main_context_owner = main_context.is_owner();
        let has_acquired_main_context = (!is_main_context_owner)
            .then(|| main_context.acquire().ok())
            .flatten();
        assert!(
            is_main_context_owner || has_acquired_main_context.is_some(),
            "Async operations only allowed if the thread is owning the MainContext"
        );

        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
        unsafe extern "C" fn flush_trampoline<P: FnOnce(Result<(), glib::Error>) + 'static>(
            _source_object: *mut glib::gobject_ffi::GObject,
            res: *mut crate::ffi::GAsyncResult,
            user_data: glib::ffi::gpointer,
        ) {
            unsafe {
                let mut error = std::ptr::null_mut();
                ffi::g_dbus_connection_flush_finish(_source_object as *mut _, res, &mut error);
                let result = if error.is_null() {
                    Ok(())
                } else {
                    Err(from_glib_full(error))
                };
                let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
                    Box_::from_raw(user_data as *mut _);
                let callback: P = callback.into_inner();
                callback(result);
            }
        }
        let callback = flush_trampoline::<P>;
        unsafe {
            ffi::g_dbus_connection_flush(
                self.to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    pub fn flush_future(
        &self,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> {
        Box_::pin(crate::GioFuture::new(
            self,
            move |obj, cancellable, send| {
                obj.flush(Some(cancellable), move |res| {
                    send.resolve(res);
                });
            },
        ))
    }

    /// Synchronously flushes @self. The calling thread is blocked
    /// until this is done. See g_dbus_connection_flush() for the
    /// asynchronous version of this method and more details about what it
    /// does.
    /// ## `cancellable`
    /// a #GCancellable or [`None`]
    ///
    /// # Returns
    ///
    /// [`true`] if the operation succeeded, [`false`] if @error is set
    #[doc(alias = "g_dbus_connection_flush_sync")]
    pub fn flush_sync(
        &self,
        cancellable: Option<&impl IsA<Cancellable>>,
    ) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::g_dbus_connection_flush_sync(
                self.to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Gets the capabilities negotiated with the remote peer
    ///
    /// # Returns
    ///
    /// zero or more flags from the #GDBusCapabilityFlags enumeration
    #[doc(alias = "g_dbus_connection_get_capabilities")]
    #[doc(alias = "get_capabilities")]
    pub fn capabilities(&self) -> DBusCapabilityFlags {
        unsafe {
            from_glib(ffi::g_dbus_connection_get_capabilities(
                self.to_glib_none().0,
            ))
        }
    }

    /// Gets whether the process is terminated when @self is
    /// closed by the remote peer. See
    /// #GDBusConnection:exit-on-close for more details.
    ///
    /// # Returns
    ///
    /// whether the process is terminated when @self is
    ///     closed by the remote peer
    #[doc(alias = "g_dbus_connection_get_exit_on_close")]
    #[doc(alias = "get_exit_on_close")]
    #[doc(alias = "exit-on-close")]
    pub fn exits_on_close(&self) -> bool {
        unsafe {
            from_glib(ffi::g_dbus_connection_get_exit_on_close(
                self.to_glib_none().0,
            ))
        }
    }

    /// Gets the flags used to construct this connection
    ///
    /// # Returns
    ///
    /// zero or more flags from the #GDBusConnectionFlags enumeration
    #[cfg(feature = "v2_60")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
    #[doc(alias = "g_dbus_connection_get_flags")]
    #[doc(alias = "get_flags")]
    pub fn flags(&self) -> DBusConnectionFlags {
        unsafe { from_glib(ffi::g_dbus_connection_get_flags(self.to_glib_none().0)) }
    }

    /// The GUID of the peer performing the role of server when
    /// authenticating. See #GDBusConnection:guid for more details.
    ///
    /// # Returns
    ///
    /// The GUID. Do not free this string, it is owned by
    ///     @self.
    #[doc(alias = "g_dbus_connection_get_guid")]
    #[doc(alias = "get_guid")]
    pub fn guid(&self) -> glib::GString {
        unsafe { from_glib_none(ffi::g_dbus_connection_get_guid(self.to_glib_none().0)) }
    }

    /// Retrieves the last serial number assigned to a #GDBusMessage on
    /// the current thread. This includes messages sent via both low-level
    /// API such as g_dbus_connection_send_message() as well as
    /// high-level API such as g_dbus_connection_emit_signal(),
    /// g_dbus_connection_call() or g_dbus_proxy_call().
    ///
    /// # Returns
    ///
    /// the last used serial or zero when no message has been sent
    ///     within the current thread
    #[doc(alias = "g_dbus_connection_get_last_serial")]
    #[doc(alias = "get_last_serial")]
    pub fn last_serial(&self) -> u32 {
        unsafe { ffi::g_dbus_connection_get_last_serial(self.to_glib_none().0) }
    }

    /// Gets the credentials of the authenticated peer. This will always
    /// return [`None`] unless @self acted as a server
    /// (e.g. [`DBusConnectionFlags::AUTHENTICATION_SERVER`][crate::DBusConnectionFlags::AUTHENTICATION_SERVER] was passed)
    /// when set up and the client passed credentials as part of the
    /// authentication process.
    ///
    /// In a message bus setup, the message bus is always the server and
    /// each application is a client. So this method will always return
    /// [`None`] for message bus clients.
    ///
    /// # Returns
    ///
    /// a #GCredentials or [`None`] if not
    ///     available. Do not free this object, it is owned by @self.
    #[doc(alias = "g_dbus_connection_get_peer_credentials")]
    #[doc(alias = "get_peer_credentials")]
    pub fn peer_credentials(&self) -> Option<Credentials> {
        unsafe {
            from_glib_none(ffi::g_dbus_connection_get_peer_credentials(
                self.to_glib_none().0,
            ))
        }
    }

    /// Gets the underlying stream used for IO.
    ///
    /// While the #GDBusConnection is active, it will interact with this
    /// stream from a worker thread, so it is not safe to interact with
    /// the stream directly.
    ///
    /// # Returns
    ///
    /// the stream used for IO
    #[doc(alias = "g_dbus_connection_get_stream")]
    #[doc(alias = "get_stream")]
    pub fn stream(&self) -> IOStream {
        unsafe { from_glib_none(ffi::g_dbus_connection_get_stream(self.to_glib_none().0)) }
    }

    /// Gets the unique name of @self as assigned by the message
    /// bus. This can also be used to figure out if @self is a
    /// message bus connection.
    ///
    /// # Returns
    ///
    /// the unique name or [`None`] if @self is not a message
    ///     bus connection. Do not free this string, it is owned by
    ///     @self.
    #[doc(alias = "g_dbus_connection_get_unique_name")]
    #[doc(alias = "get_unique_name")]
    #[doc(alias = "unique-name")]
    pub fn unique_name(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::g_dbus_connection_get_unique_name(
                self.to_glib_none().0,
            ))
        }
    }

    /// Gets whether @self is closed.
    ///
    /// # Returns
    ///
    /// [`true`] if the connection is closed, [`false`] otherwise
    #[doc(alias = "g_dbus_connection_is_closed")]
    #[doc(alias = "closed")]
    pub fn is_closed(&self) -> bool {
        unsafe { from_glib(ffi::g_dbus_connection_is_closed(self.to_glib_none().0)) }
    }

    /// Asynchronously sends @message to the peer represented by @self.
    ///
    /// Unless @flags contain the
    /// [`DBusSendMessageFlags::PRESERVE_SERIAL`][crate::DBusSendMessageFlags::PRESERVE_SERIAL] flag, the serial number
    /// will be assigned by @self and set on @message via
    /// g_dbus_message_set_serial(). If @out_serial is not [`None`], then the
    /// serial number used will be written to this location prior to
    /// submitting the message to the underlying transport. While it has a `volatile`
    /// qualifier, this is a historical artifact and the argument passed to it should
    /// not be `volatile`.
    ///
    /// If @self is closed then the operation will fail with
    /// [`IOErrorEnum::Closed`][crate::IOErrorEnum::Closed]. If @message is not well-formed,
    /// the operation fails with [`IOErrorEnum::InvalidArgument`][crate::IOErrorEnum::InvalidArgument].
    ///
    /// See this [server][`DBusConnection`][crate::DBusConnection]#an-example-d-bus-server]
    /// and [client][`DBusConnection`][crate::DBusConnection]#an-example-for-file-descriptor-passing]
    /// for an example of how to use this low-level API to send and receive
    /// UNIX file descriptors.
    ///
    /// Note that @message must be unlocked, unless @flags contain the
    /// [`DBusSendMessageFlags::PRESERVE_SERIAL`][crate::DBusSendMessageFlags::PRESERVE_SERIAL] flag.
    /// ## `message`
    /// a #GDBusMessage
    /// ## `flags`
    /// flags affecting how the message is sent
    ///
    /// # Returns
    ///
    /// [`true`] if the message was well-formed and queued for
    ///     transmission, [`false`] if @error is set
    ///
    /// ## `out_serial`
    /// return location for serial number assigned
    ///     to @message when sending it or [`None`]
    #[doc(alias = "g_dbus_connection_send_message")]
    pub fn send_message(
        &self,
        message: &DBusMessage,
        flags: DBusSendMessageFlags,
    ) -> Result<u32, glib::Error> {
        unsafe {
            let mut out_serial = std::mem::MaybeUninit::uninit();
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::g_dbus_connection_send_message(
                self.to_glib_none().0,
                message.to_glib_none().0,
                flags.into_glib(),
                out_serial.as_mut_ptr(),
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(out_serial.assume_init())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Asynchronously sends @message to the peer represented by @self.
    ///
    /// Unless @flags contain the
    /// [`DBusSendMessageFlags::PRESERVE_SERIAL`][crate::DBusSendMessageFlags::PRESERVE_SERIAL] flag, the serial number
    /// will be assigned by @self and set on @message via
    /// g_dbus_message_set_serial(). If @out_serial is not [`None`], then the
    /// serial number used will be written to this location prior to
    /// submitting the message to the underlying transport. While it has a `volatile`
    /// qualifier, this is a historical artifact and the argument passed to it should
    /// not be `volatile`.
    ///
    /// If @self is closed then the operation will fail with
    /// [`IOErrorEnum::Closed`][crate::IOErrorEnum::Closed]. If @cancellable is canceled, the operation will
    /// fail with [`IOErrorEnum::Cancelled`][crate::IOErrorEnum::Cancelled]. If @message is not well-formed,
    /// the operation fails with [`IOErrorEnum::InvalidArgument`][crate::IOErrorEnum::InvalidArgument].
    ///
    /// This is an asynchronous method. When the operation is finished, @callback
    /// will be invoked in the thread-default main context
    /// (see [`glib::MainContext::push_thread_default()`][crate::glib::MainContext::push_thread_default()])
    /// of the thread you are calling this method from. You can then call
    /// g_dbus_connection_send_message_with_reply_finish() to get the result of the operation.
    /// See g_dbus_connection_send_message_with_reply_sync() for the synchronous version.
    ///
    /// Note that @message must be unlocked, unless @flags contain the
    /// [`DBusSendMessageFlags::PRESERVE_SERIAL`][crate::DBusSendMessageFlags::PRESERVE_SERIAL] flag.
    ///
    /// See this [server][`DBusConnection`][crate::DBusConnection]#an-example-d-bus-server]
    /// and [client][`DBusConnection`][crate::DBusConnection]#an-example-for-file-descriptor-passing]
    /// for an example of how to use this low-level API to send and receive
    /// UNIX file descriptors.
    /// ## `message`
    /// a #GDBusMessage
    /// ## `flags`
    /// flags affecting how the message is sent
    /// ## `timeout_msec`
    /// the timeout in milliseconds, -1 to use the default
    ///     timeout or `G_MAXINT` for no timeout
    /// ## `cancellable`
    /// a #GCancellable or [`None`]
    /// ## `callback`
    /// a #GAsyncReadyCallback to call when the request
    ///     is satisfied or [`None`] if you don't care about the result
    ///
    /// # Returns
    ///
    ///
    /// ## `out_serial`
    /// return location for serial number assigned
    ///     to @message when sending it or [`None`]
    #[doc(alias = "g_dbus_connection_send_message_with_reply")]
    pub fn send_message_with_reply<P: FnOnce(Result<DBusMessage, glib::Error>) + 'static>(
        &self,
        message: &DBusMessage,
        flags: DBusSendMessageFlags,
        timeout_msec: i32,
        cancellable: Option<&impl IsA<Cancellable>>,
        callback: P,
    ) -> u32 {
        let main_context = glib::MainContext::ref_thread_default();
        let is_main_context_owner = main_context.is_owner();
        let has_acquired_main_context = (!is_main_context_owner)
            .then(|| main_context.acquire().ok())
            .flatten();
        assert!(
            is_main_context_owner || has_acquired_main_context.is_some(),
            "Async operations only allowed if the thread is owning the MainContext"
        );

        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
        unsafe extern "C" fn send_message_with_reply_trampoline<
            P: FnOnce(Result<DBusMessage, glib::Error>) + 'static,
        >(
            _source_object: *mut glib::gobject_ffi::GObject,
            res: *mut crate::ffi::GAsyncResult,
            user_data: glib::ffi::gpointer,
        ) {
            unsafe {
                let mut error = std::ptr::null_mut();
                let ret = ffi::g_dbus_connection_send_message_with_reply_finish(
                    _source_object as *mut _,
                    res,
                    &mut error,
                );
                let result = if error.is_null() {
                    Ok(from_glib_full(ret))
                } else {
                    Err(from_glib_full(error))
                };
                let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
                    Box_::from_raw(user_data as *mut _);
                let callback: P = callback.into_inner();
                callback(result);
            }
        }
        let callback = send_message_with_reply_trampoline::<P>;
        unsafe {
            let mut out_serial = std::mem::MaybeUninit::uninit();
            ffi::g_dbus_connection_send_message_with_reply(
                self.to_glib_none().0,
                message.to_glib_none().0,
                flags.into_glib(),
                timeout_msec,
                out_serial.as_mut_ptr(),
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
            out_serial.assume_init()
        }
    }

    pub fn send_message_with_reply_future(
        &self,
        message: &DBusMessage,
        flags: DBusSendMessageFlags,
        timeout_msec: i32,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<DBusMessage, glib::Error>> + 'static>>
    {
        let message = message.clone();
        Box_::pin(crate::GioFuture::new(
            self,
            move |obj, cancellable, send| {
                obj.send_message_with_reply(
                    &message,
                    flags,
                    timeout_msec,
                    Some(cancellable),
                    move |res| {
                        send.resolve(res);
                    },
                );
            },
        ))
    }

    /// Synchronously sends @message to the peer represented by @self
    /// and blocks the calling thread until a reply is received or the
    /// timeout is reached. See g_dbus_connection_send_message_with_reply()
    /// for the asynchronous version of this method.
    ///
    /// Unless @flags contain the
    /// [`DBusSendMessageFlags::PRESERVE_SERIAL`][crate::DBusSendMessageFlags::PRESERVE_SERIAL] flag, the serial number
    /// will be assigned by @self and set on @message via
    /// g_dbus_message_set_serial(). If @out_serial is not [`None`], then the
    /// serial number used will be written to this location prior to
    /// submitting the message to the underlying transport. While it has a `volatile`
    /// qualifier, this is a historical artifact and the argument passed to it should
    /// not be `volatile`.
    ///
    /// If @self is closed then the operation will fail with
    /// [`IOErrorEnum::Closed`][crate::IOErrorEnum::Closed]. If @cancellable is canceled, the operation will
    /// fail with [`IOErrorEnum::Cancelled`][crate::IOErrorEnum::Cancelled]. If @message is not well-formed,
    /// the operation fails with [`IOErrorEnum::InvalidArgument`][crate::IOErrorEnum::InvalidArgument].
    ///
    /// Note that @error is only set if a local in-process error
    /// occurred. That is to say that the returned #GDBusMessage object may
    /// be of type [`DBusMessageType::Error`][crate::DBusMessageType::Error]. Use
    /// g_dbus_message_to_gerror() to transcode this to a #GError.
    ///
    /// See this [server][`DBusConnection`][crate::DBusConnection]#an-example-d-bus-server]
    /// and [client][`DBusConnection`][crate::DBusConnection]#an-example-for-file-descriptor-passing]
    /// for an example of how to use this low-level API to send and receive
    /// UNIX file descriptors.
    ///
    /// Note that @message must be unlocked, unless @flags contain the
    /// [`DBusSendMessageFlags::PRESERVE_SERIAL`][crate::DBusSendMessageFlags::PRESERVE_SERIAL] flag.
    /// ## `message`
    /// a #GDBusMessage
    /// ## `flags`
    /// flags affecting how the message is sent.
    /// ## `timeout_msec`
    /// the timeout in milliseconds, -1 to use the default
    ///     timeout or `G_MAXINT` for no timeout
    /// ## `cancellable`
    /// a #GCancellable or [`None`]
    ///
    /// # Returns
    ///
    /// a locked #GDBusMessage that is the reply
    ///     to @message or [`None`] if @error is set
    ///
    /// ## `out_serial`
    /// return location for serial number
    ///     assigned to @message when sending it or [`None`]
    #[doc(alias = "g_dbus_connection_send_message_with_reply_sync")]
    pub fn send_message_with_reply_sync(
        &self,
        message: &DBusMessage,
        flags: DBusSendMessageFlags,
        timeout_msec: i32,
        cancellable: Option<&impl IsA<Cancellable>>,
    ) -> Result<(DBusMessage, u32), glib::Error> {
        unsafe {
            let mut out_serial = std::mem::MaybeUninit::uninit();
            let mut error = std::ptr::null_mut();
            let ret = ffi::g_dbus_connection_send_message_with_reply_sync(
                self.to_glib_none().0,
                message.to_glib_none().0,
                flags.into_glib(),
                timeout_msec,
                out_serial.as_mut_ptr(),
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok((from_glib_full(ret), out_serial.assume_init()))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Sets whether the process should be terminated when @self is
    /// closed by the remote peer. See #GDBusConnection:exit-on-close for
    /// more details.
    ///
    /// Note that this function should be used with care. Most modern UNIX
    /// desktops tie the notion of a user session with the session bus, and expect
    /// all of a user's applications to quit when their bus connection goes away.
    /// If you are setting @exit_on_close to [`false`] for the shared session
    /// bus connection, you should make sure that your application exits
    /// when the user session ends.
    /// ## `exit_on_close`
    /// whether the process should be terminated
    ///     when @self is closed by the remote peer
    #[doc(alias = "g_dbus_connection_set_exit_on_close")]
    #[doc(alias = "exit-on-close")]
    pub fn set_exit_on_close(&self, exit_on_close: bool) {
        unsafe {
            ffi::g_dbus_connection_set_exit_on_close(
                self.to_glib_none().0,
                exit_on_close.into_glib(),
            );
        }
    }

    /// If @self was created with
    /// [`DBusConnectionFlags::DELAY_MESSAGE_PROCESSING`][crate::DBusConnectionFlags::DELAY_MESSAGE_PROCESSING], this method
    /// starts processing messages. Does nothing on if @self wasn't
    /// created with this flag or if the method has already been called.
    #[doc(alias = "g_dbus_connection_start_message_processing")]
    pub fn start_message_processing(&self) {
        unsafe {
            ffi::g_dbus_connection_start_message_processing(self.to_glib_none().0);
        }
    }

    #[cfg(not(feature = "v2_60"))]
    #[cfg_attr(docsrs, doc(cfg(not(feature = "v2_60"))))]
    pub fn flags(&self) -> DBusConnectionFlags {
        ObjectExt::property(self, "flags")
    }

    /// Asynchronously sets up a D-Bus connection for exchanging D-Bus messages
    /// with the end represented by @stream.
    ///
    /// If @stream is a #GSocketConnection, then the corresponding #GSocket
    /// will be put into non-blocking mode.
    ///
    /// The D-Bus connection will interact with @stream from a worker thread.
    /// As a result, the caller should not interact with @stream after this
    /// method has been called, except by calling g_object_unref() on it.
    ///
    /// If @observer is not [`None`] it may be used to control the
    /// authentication process.
    ///
    /// When the operation is finished, @callback will be invoked. You can
    /// then call g_dbus_connection_new_finish() to get the result of the
    /// operation.
    ///
    /// This is an asynchronous failable constructor. See
    /// g_dbus_connection_new_sync() for the synchronous
    /// version.
    /// ## `stream`
    /// a #GIOStream
    /// ## `guid`
    /// the GUID to use if authenticating as a server or [`None`]
    /// ## `flags`
    /// flags describing how to make the connection
    /// ## `observer`
    /// a #GDBusAuthObserver or [`None`]
    /// ## `cancellable`
    /// a #GCancellable or [`None`]
    /// ## `callback`
    /// a #GAsyncReadyCallback to call when the request is satisfied
    #[doc(alias = "g_dbus_connection_new")]
    pub fn new<P: FnOnce(Result<DBusConnection, glib::Error>) + 'static>(
        stream: &impl IsA<IOStream>,
        guid: Option<&str>,
        flags: DBusConnectionFlags,
        observer: Option<&DBusAuthObserver>,
        cancellable: Option<&impl IsA<Cancellable>>,
        callback: P,
    ) {
        let main_context = glib::MainContext::ref_thread_default();
        let is_main_context_owner = main_context.is_owner();
        let has_acquired_main_context = (!is_main_context_owner)
            .then(|| main_context.acquire().ok())
            .flatten();
        assert!(
            is_main_context_owner || has_acquired_main_context.is_some(),
            "Async operations only allowed if the thread is owning the MainContext"
        );

        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
        unsafe extern "C" fn new_trampoline<
            P: FnOnce(Result<DBusConnection, glib::Error>) + 'static,
        >(
            _source_object: *mut glib::gobject_ffi::GObject,
            res: *mut crate::ffi::GAsyncResult,
            user_data: glib::ffi::gpointer,
        ) {
            unsafe {
                let mut error = std::ptr::null_mut();
                let ret = ffi::g_dbus_connection_new_finish(res, &mut error);
                let result = if error.is_null() {
                    Ok(from_glib_full(ret))
                } else {
                    Err(from_glib_full(error))
                };
                let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
                    Box_::from_raw(user_data as *mut _);
                let callback: P = callback.into_inner();
                callback(result);
            }
        }
        let callback = new_trampoline::<P>;
        unsafe {
            ffi::g_dbus_connection_new(
                stream.as_ref().to_glib_none().0,
                guid.to_glib_none().0,
                flags.into_glib(),
                observer.to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    pub fn new_future(
        stream: &(impl IsA<IOStream> + Clone + 'static),
        guid: Option<&str>,
        flags: DBusConnectionFlags,
        observer: Option<&DBusAuthObserver>,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<DBusConnection, glib::Error>> + 'static>>
    {
        let stream = stream.clone();
        let guid = guid.map(ToOwned::to_owned);
        let observer = observer.map(ToOwned::to_owned);
        Box_::pin(crate::GioFuture::new(
            &(),
            move |_obj, cancellable, send| {
                Self::new(
                    &stream,
                    guid.as_ref().map(::std::borrow::Borrow::borrow),
                    flags,
                    observer.as_ref().map(::std::borrow::Borrow::borrow),
                    Some(cancellable),
                    move |res| {
                        send.resolve(res);
                    },
                );
            },
        ))
    }

    /// Asynchronously connects and sets up a D-Bus client connection for
    /// exchanging D-Bus messages with an endpoint specified by @address
    /// which must be in the
    /// [D-Bus address format](https://dbus.freedesktop.org/doc/dbus-specification.html#addresses).
    ///
    /// This constructor can only be used to initiate client-side
    /// connections - use g_dbus_connection_new() if you need to act as the
    /// server. In particular, @flags cannot contain the
    /// [`DBusConnectionFlags::AUTHENTICATION_SERVER`][crate::DBusConnectionFlags::AUTHENTICATION_SERVER],
    /// [`DBusConnectionFlags::AUTHENTICATION_ALLOW_ANONYMOUS`][crate::DBusConnectionFlags::AUTHENTICATION_ALLOW_ANONYMOUS] or
    /// [`DBusConnectionFlags::AUTHENTICATION_REQUIRE_SAME_USER`][crate::DBusConnectionFlags::AUTHENTICATION_REQUIRE_SAME_USER] flags.
    ///
    /// When the operation is finished, @callback will be invoked. You can
    /// then call g_dbus_connection_new_for_address_finish() to get the result of
    /// the operation.
    ///
    /// If @observer is not [`None`] it may be used to control the
    /// authentication process.
    ///
    /// This is an asynchronous failable constructor. See
    /// g_dbus_connection_new_for_address_sync() for the synchronous
    /// version.
    /// ## `address`
    /// a D-Bus address
    /// ## `flags`
    /// flags describing how to make the connection
    /// ## `observer`
    /// a #GDBusAuthObserver or [`None`]
    /// ## `cancellable`
    /// a #GCancellable or [`None`]
    /// ## `callback`
    /// a #GAsyncReadyCallback to call when the request is satisfied
    #[doc(alias = "g_dbus_connection_new_for_address")]
    #[doc(alias = "new_for_address")]
    pub fn for_address<P: FnOnce(Result<DBusConnection, glib::Error>) + 'static>(
        address: &str,
        flags: DBusConnectionFlags,
        observer: Option<&DBusAuthObserver>,
        cancellable: Option<&impl IsA<Cancellable>>,
        callback: P,
    ) {
        let main_context = glib::MainContext::ref_thread_default();
        let is_main_context_owner = main_context.is_owner();
        let has_acquired_main_context = (!is_main_context_owner)
            .then(|| main_context.acquire().ok())
            .flatten();
        assert!(
            is_main_context_owner || has_acquired_main_context.is_some(),
            "Async operations only allowed if the thread is owning the MainContext"
        );

        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
        unsafe extern "C" fn for_address_trampoline<
            P: FnOnce(Result<DBusConnection, glib::Error>) + 'static,
        >(
            _source_object: *mut glib::gobject_ffi::GObject,
            res: *mut crate::ffi::GAsyncResult,
            user_data: glib::ffi::gpointer,
        ) {
            unsafe {
                let mut error = std::ptr::null_mut();
                let ret = ffi::g_dbus_connection_new_for_address_finish(res, &mut error);
                let result = if error.is_null() {
                    Ok(from_glib_full(ret))
                } else {
                    Err(from_glib_full(error))
                };
                let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
                    Box_::from_raw(user_data as *mut _);
                let callback: P = callback.into_inner();
                callback(result);
            }
        }
        let callback = for_address_trampoline::<P>;
        unsafe {
            ffi::g_dbus_connection_new_for_address(
                address.to_glib_none().0,
                flags.into_glib(),
                observer.to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    pub fn for_address_future(
        address: &str,
        flags: DBusConnectionFlags,
        observer: Option<&DBusAuthObserver>,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<DBusConnection, glib::Error>> + 'static>>
    {
        let address = String::from(address);
        let observer = observer.map(ToOwned::to_owned);
        Box_::pin(crate::GioFuture::new(
            &(),
            move |_obj, cancellable, send| {
                Self::for_address(
                    &address,
                    flags,
                    observer.as_ref().map(::std::borrow::Borrow::borrow),
                    Some(cancellable),
                    move |res| {
                        send.resolve(res);
                    },
                );
            },
        ))
    }

    /// Emitted when the connection is closed.
    ///
    /// The cause of this event can be
    ///
    /// - If g_dbus_connection_close() is called. In this case
    ///   @remote_peer_vanished is set to [`false`] and @error is [`None`].
    ///
    /// - If the remote peer closes the connection. In this case
    ///   @remote_peer_vanished is set to [`true`] and @error is set.
    ///
    /// - If the remote peer sends invalid or malformed data. In this
    ///   case @remote_peer_vanished is set to [`false`] and @error is set.
    ///
    /// Upon receiving this signal, you should give up your reference to
    /// @connection. You are guaranteed that this signal is emitted only
    /// once.
    /// ## `remote_peer_vanished`
    /// [`true`] if @connection is closed because the
    ///     remote peer closed its end of the connection
    /// ## `error`
    /// a #GError with more details about the event or [`None`]
    #[doc(alias = "closed")]
    pub fn connect_closed<F: Fn(&Self, bool, Option<&glib::Error>) + Send + Sync + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn closed_trampoline<
            F: Fn(&DBusConnection, bool, Option<&glib::Error>) + Send + Sync + 'static,
        >(
            this: *mut ffi::GDBusConnection,
            remote_peer_vanished: glib::ffi::gboolean,
            error: *mut glib::ffi::GError,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(
                    &from_glib_borrow(this),
                    from_glib(remote_peer_vanished),
                    Option::<glib::Error>::from_glib_borrow(error)
                        .as_ref()
                        .as_ref(),
                )
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"closed".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    closed_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "capabilities")]
    pub fn connect_capabilities_notify<F: Fn(&Self) + Send + Sync + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_capabilities_trampoline<
            F: Fn(&DBusConnection) + Send + Sync + 'static,
        >(
            this: *mut ffi::GDBusConnection,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::capabilities".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_capabilities_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "closed")]
    pub fn connect_closed_notify<F: Fn(&Self) + Send + Sync + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_closed_trampoline<
            F: Fn(&DBusConnection) + Send + Sync + 'static,
        >(
            this: *mut ffi::GDBusConnection,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::closed".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_closed_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "exit-on-close")]
    pub fn connect_exit_on_close_notify<F: Fn(&Self) + Send + Sync + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_exit_on_close_trampoline<
            F: Fn(&DBusConnection) + Send + Sync + 'static,
        >(
            this: *mut ffi::GDBusConnection,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::exit-on-close".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_exit_on_close_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "unique-name")]
    pub fn connect_unique_name_notify<F: Fn(&Self) + Send + Sync + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_unique_name_trampoline<
            F: Fn(&DBusConnection) + Send + Sync + 'static,
        >(
            this: *mut ffi::GDBusConnection,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::unique-name".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_unique_name_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

unsafe impl Send for DBusConnection {}
unsafe impl Sync for DBusConnection {}