Back to Seed Clases

Gio

Classes

Interfaces

Structs

Unions

Enums

GObject.Object
parent-child marker Gio.DBusConnection

Class Gio.DBusConnection

Import line:	Gio = imports.gi.Gio;
GIR File:	Gio-2.0.gir
C documentation:	GDBusConnection
Class :	DBusConnection
Implements:	Gio.AsyncInitable, Gio.Initable
Extends:	GObject.Object

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 an GIOStream.
This class is rarely used directly in D-Bus clients. If you are writing
an D-Bus client, it is often easier to use the g_bus_own_name(),
g_bus_watch_name() or g_dbus_proxy_new_for_bus() APIs.
D-Bus server exampleFIXME: MISSING XINCLUDE CONTENT
D-Bus subtree exampleFIXME: MISSING XINCLUDE CONTENT
D-Bus UNIX File Descriptor exampleFIXME: MISSING XINCLUDE CONTENT
Exporting a GObjectFIXME: MISSING XINCLUDE CONTENT

Properties
Properties		Defined By
	address : String A D-Bus address specifying potential endpoints that can be used when establishing the connection. A D-Bus address specifying potential endpoints that can be used when establishing the connection.	Gio.DBusConnection
	authentication_observer : Gio.DBusAuthObserver A GDBusAuthObserver object to assist in the authentication process or NULL. A GDBusAuthObserver object to assist in the authentication process or NULL.	Gio.DBusConnection
	capabilities : Gio.DBusCapabilityFlags read only Flags from the GDBusCapabilityFlags enumeration representing connection features negotiated with the other peer. Flags from the GDBusCapabilityFlags enumeration representing connection features negotiated with the other peer.	Gio.DBusConnection
	closed : gboolean read only A boolean specifying whether the connection has been closed. A boolean specifying whether the connection has been closed.	Gio.DBusConnection
	exit_on_close : gboolean A boolean specifying whether the process will be terminated (by calling raise(SIGTERM)) if the connection is closed by the remote peer. A boolean specifying whether the process will be terminated (by calling raise(SIGTERM)) if the connection is closed by the remote peer.	Gio.DBusConnection
	flags : Gio.DBusConnectionFlags Flags from the GDBusConnectionFlags enumeration. Flags from the GDBusConnectionFlags enumeration.	Gio.DBusConnection
	guid : String The GUID of the peer performing the role of server when authenticating. The GUID of the peer performing the role of server when authenticating. If you are constructing a GDBusConnection and pass G_DBUS_CONNECTION_FLAGS_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 G_DBUS_CONNECTION_FLAGS_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.	Gio.DBusConnection
	stream : Gio.IOStream The underlying GIOStream used for I/O. The underlying GIOStream used for I/O.	Gio.DBusConnection
	unique_name : String read only The unique name as assigned by the message bus or NULL if the connection is not open or not a message bus connection. The unique name as assigned by the message bus or NULL if the connection is not open or not a message bus connection.	Gio.DBusConnection

Methods / Constructors
Method / Constructor		Defined By
	new Gio.DBusConnection (Object *properties) Create a new Gio.DBusConnection Create a new Gio.DBusConnection Parameters: Object properties*
	new Gio.DBusConnection.finish (AsyncResult *res) : Gio.DBusConnection Create a new Gio.DBusConnection Create a new Gio.DBusConnection Parameters: Gio.AsyncResult res* Required (not null) A GAsyncResult obtained from the GAsyncReadyCallback passed to g_dbus_connection_new(). Returns: Gio.DBusConnection A GDBusConnection or NULL if error is set. Free with g_object_unref().
	new Gio.DBusConnection.for_address_finish (AsyncResult *res) : Gio.DBusConnection Create a new Gio.DBusConnection Create a new Gio.DBusConnection Parameters: Gio.AsyncResult res* Required (not null) A GAsyncResult obtained from the GAsyncReadyCallback passed to g_dbus_connection_new(). Returns: Gio.DBusConnection A GDBusConnection or NULL if error is set. Free with g_object_unref().
	new Gio.DBusConnection.for_address_sync (String *address, DBusConnectionFlags flags, DBusAuthObserver observer, Cancellable cancellable) : Gio.DBusConnection Create a new Gio.DBusConnection Create a new Gio.DBusConnection Parameters: String address* Required (not null) A D-Bus address. Gio.DBusConnectionFlags flags Required (not null) Flags describing how to make the connection. Gio.DBusAuthObserver observer Required (not null) A GDBusAuthObserver or NULL. Gio.Cancellable cancellable A GCancellable or NULL. Returns: Gio.DBusConnection A GDBusConnection or NULL if error is set. Free with g_object_unref().
	new Gio.DBusConnection.sync (IOStream *stream, String guid, DBusConnectionFlags flags, DBusAuthObserver observer, Cancellable cancellable) : Gio.DBusConnection Create a new Gio.DBusConnection Create a new Gio.DBusConnection Parameters: Gio.IOStream stream* Required (not null) A GIOStream. String guid Required (not null) The GUID to use if a authenticating as a server or NULL. Gio.DBusConnectionFlags flags Required (not null) Flags describing how to make the connection. Gio.DBusAuthObserver observer Required (not null) A GDBusAuthObserver or NULL. Gio.Cancellable cancellable A GCancellable or NULL. Returns: Gio.DBusConnection A GDBusConnection or NULL if error is set. Free with g_object_unref().
	Gio.DBusConnection.c_new (IOStream *stream, String guid, DBusConnectionFlags flags, DBusAuthObserver observer, Cancellable cancellable, Function callback, void *user_data) : none Asynchronously sets up a D-Bus connection for exchanging D-Bus messages with the end represented by stream. Asynchronously sets up a D-Bus connection for exchanging D-Bus messages with the end represented by stream. If observer* is not NULL 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 a asynchronous failable constructor. See g_dbus_connection_new_sync() for the synchronous version. Parameters: Gio.IOStream stream Required (not null) A GIOStream. String guid Required (not null) The GUID to use if a authenticating as a server or NULL. Gio.DBusConnectionFlags flags Required (not null) Flags describing how to make the connection. Gio.DBusAuthObserver observer Required (not null) A GDBusAuthObserver or NULL. Gio.Cancellable cancellable A GCancellable or NULL. Function (Object *source_object, AsyncResult res, void *user_data) : none Required (not null) A GAsyncReadyCallback* to call when the request is satisfied. void* user_data Required (not null) The data to pass to callback. Returns: none	Gio.DBusConnection
	Gio.DBusConnection.new_for_address (String *address, DBusConnectionFlags flags, DBusAuthObserver observer, Cancellable cancellable, Function callback, void *user_data) : none 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. 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. 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 G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_SERVER or G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_ALLOW_ANONYMOUS flags. 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. If observer is not NULL it may be used to control the authentication process. This is a asynchronous failable constructor. See g_dbus_connection_new_for_address_sync() for the synchronous version. Parameters: String address Required (not null) A D-Bus address. Gio.DBusConnectionFlags flags Required (not null) Flags describing how to make the connection. Gio.DBusAuthObserver observer Required (not null) A GDBusAuthObserver or NULL. Gio.Cancellable cancellable A GCancellable or NULL. Function (Object *source_object, AsyncResult res, void *user_data) : none Required (not null) A GAsyncReadyCallback* to call when the request is satisfied. void* user_data Required (not null) The data to pass to callback. Returns: none	Gio.DBusConnection
	add_filter (Function *filter_function, void *user_data, Function user_data_free_func) : guint32 Adds a message filter. Adds a message filter. Filters are handlers that are run on all incoming and outgoing messages, prior to standard dispatch. Filters are run in the order that they were added. The same handler can be added as a filter more than once, in which case it will be run more than once. Filters added during a filter callback won't be run on the message being processed. Filter functions are allowed to modify and even drop messages - see the GDBusMessageFilterResult* enumeration for details. Note that filters are run in a dedicated message handling thread so they can't block and, generally, can't do anything but signal a worker thread. Also note that filters are rarely needed - use API such as g_dbus_connection_send_message_with_reply(), g_dbus_connection_signal_subscribe() or g_dbus_connection_call() instead. If a filter consumes an incoming message the message is not dispatched anywhere else - not even the standard dispatch machinery (that API such as g_dbus_connection_signal_subscribe() and g_dbus_connection_send_message_with_reply() relies on) will see the message. Similary, if a filter consumes an outgoing message, the message will not be sent to the other peer. g_dbus_connection_remove_filter(). Parameters: Function (DBusConnection *connection, DBusMessage message, gboolean incoming, void *user_data) : guint32 Required (not null) A filter function. void user_data Required (not null) User data to pass to filter_function. Function (void* *data) : guint32 Required (not null) Function to free user_data* with when filter is removed or NULL. Returns: guint32 A filter identifier that can be used with	Gio.DBusConnection
	call (String *bus_name, String object_path, String interface_name, String method_name, Variant parameters, VariantType reply_type, DBusCallFlags flags, gint32 timeout_msec, Cancellable cancellable, Function callback, void *user_data) : none Asynchronously invokes the method_name* method on the If connection is closed then the operation will fail with G_IO_ERROR_CLOSED. Asynchronously invokes the method_name method on the If connection is closed then the operation will fail with G_IO_ERROR_CLOSED. If cancellable is canceled, the operation will fail with G_IO_ERROR_CANCELLED. If parameters contains a value not compatible with the D-Bus protocol, the operation fails with G_IO_ERROR_INVALID_ARGUMENT. If reply_type is non-NULL then the reply will be checked for having this type and an error will be raised if it does not match. Said another way, if you give a reply_type then any non-NULL return value will be of this type. If the parameters GVariant is floating, it is consumed. This allows convenient 'inline' use of g_variant_new(), e.g.: \|[ 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 loop 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. Parameters: String bus_name Required (not null) A unique or well-known bus name or NULL if connection is not a message bus connection. String object_path Required (not null) Path of remote object. String interface_name Required (not null) D-Bus interface to invoke method on. String method_name Required (not null) The name of the method to invoke. GLib.Variant parameters Required (not null) A GVariant tuple with parameters for the method or NULL if not passing parameters. GLib.VariantType reply_type Required (not null) The expected type of the reply, or NULL. Gio.DBusCallFlags flags Required (not null) Flags from the GDBusCallFlags enumeration. gint32 timeout_msec Required (not null) The timeout in milliseconds, -1 to use the default timeout or G_MAXINT for no timeout. Gio.Cancellable cancellable A GCancellable or NULL. Function (Object *source_object, AsyncResult res, void *user_data) : none Required (not null) A GAsyncReadyCallback* to call when the request is satisfied or NULL if you don't care about the result of the method invocation. void* user_data Required (not null) The data to pass to callback. Returns: none	Gio.DBusConnection
	call_finish (AsyncResult *res) : GLib.Variant Finishes an operation started with g_dbus_connection_call(). Finishes an operation started with g_dbus_connection_call(). return values. Free with g_variant_unref(). Parameters: Gio.AsyncResult res* Required (not null) A GAsyncResult obtained from the GAsyncReadyCallback passed to g_dbus_connection_call(). Returns: GLib.Variant NULL if error is set. Otherwise a GVariant tuple with	Gio.DBusConnection
	call_sync (String *bus_name, String object_path, String interface_name, String method_name, Variant parameters, VariantType reply_type, DBusCallFlags flags, gint32 timeout_msec, Cancellable cancellable) : GLib.Variant Synchronously invokes the method_name* method on the If connection is closed then the operation will fail with G_IO_ERROR_CLOSED. Synchronously invokes the method_name method on the If connection is closed then the operation will fail with G_IO_ERROR_CLOSED. If cancellable is canceled, the operation will fail with G_IO_ERROR_CANCELLED. If parameters contains a value not compatible with the D-Bus protocol, the operation fails with G_IO_ERROR_INVALID_ARGUMENT. If reply_type is non-NULL then the reply will be checked for having this type and an error will be raised if it does not match. Said another way, if you give a reply_type then any non-NULL return value will be of this type. If the parameters GVariant is floating, it is consumed. This allows convenient 'inline' use of g_variant_new(), e.g.: \|[ g_dbus_connection_call_sync (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, &error); ]\| The calling thread is blocked until a reply is received. See g_dbus_connection_call() for the asynchronous version of this method. return values. Free with g_variant_unref(). Parameters: String bus_name Required (not null) A unique or well-known bus name. String object_path Required (not null) Path of remote object. String interface_name Required (not null) D-Bus interface to invoke method on. String method_name Required (not null) The name of the method to invoke. GLib.Variant parameters Required (not null) A GVariant tuple with parameters for the method or NULL if not passing parameters. GLib.VariantType reply_type Required (not null) The expected type of the reply, or NULL. Gio.DBusCallFlags flags Required (not null) Flags from the GDBusCallFlags enumeration. gint32 timeout_msec Required (not null) The timeout in milliseconds, -1 to use the default timeout or G_MAXINT for no timeout. Gio.Cancellable cancellable A GCancellable or NULL. Returns: GLib.Variant NULL if error is set. Otherwise a GVariant tuple with	Gio.DBusConnection
	close (Cancellable *cancellable, Function callback, void *user_data) : none Closes connection. Closes connection. 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 G_IO_ERROR_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 connection* is already closed, this method fails with G_IO_ERROR_CLOSED. When connection has been closed, the GDBusConnection::closed signal is emitted in the linkend="g-main-context-push-thread-default">thread-default main loop of the thread that connection was constructed in. This is an asynchronous method. When the operation is finished, linkend="g-main-context-push-thread-default">thread-default main loop 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. Parameters: Gio.Cancellable cancellable A GCancellable or NULL. Function (Object *source_object, AsyncResult res, void *user_data) : none Required (not null) A GAsyncReadyCallback* to call when the request is satisfied or NULL if you don't care about the result. void* user_data Required (not null) The data to pass to callback. Returns: none	Gio.DBusConnection
	close_finish (AsyncResult *res) : gboolean Finishes an operation started with g_dbus_connection_close(). Finishes an operation started with g_dbus_connection_close(). Parameters: Gio.AsyncResult res* Required (not null) A GAsyncResult obtained from the GAsyncReadyCallback passed to g_dbus_connection_close(). Returns: gboolean TRUE if the operation succeeded, FALSE if error is set.	Gio.DBusConnection
	close_sync (Cancellable *cancellable) : gboolean Synchronously closees connection. Synchronously closees connection. 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. Parameters: Gio.Cancellable cancellable* A GCancellable or NULL. Returns: gboolean TRUE if the operation succeeded, FALSE if error is set.	Gio.DBusConnection
	emit_signal (String *destination_bus_name, String object_path, String interface_name, String signal_name, Variant parameters) : gboolean Emits a signal. 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. Parameters: String destination_bus_name Required (not null) The unique bus name for the destination for the signal or NULL to emit to all listeners. String object_path Required (not null) Path of remote object. String interface_name Required (not null) D-Bus interface to emit a signal on. String signal_name Required (not null) The name of the signal to emit. GLib.Variant parameters Required (not null) A GVariant tuple with parameters for the signal or NULL if not passing parameters. Returns: gboolean TRUE unless error is set.	Gio.DBusConnection
	flush (Cancellable *cancellable, Function callback, void *user_data) : none Asynchronously flushes connection, that is, writes all queued outgoing message to the transport and then flushes the transport (using g_output_stream_flush_async()). Asynchronously flushes connection, that is, writes all queued outgoing message to the transport and then flushes the transport (using g_output_stream_flush_async()). This is useful in programs that wants 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, linkend="g-main-context-push-thread-default">thread-default main loop 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. Parameters: Gio.Cancellable cancellable* A GCancellable or NULL. Function (Object *source_object, AsyncResult res, void *user_data) : none Required (not null) A GAsyncReadyCallback* to call when the request is satisfied or NULL if you don't care about the result. void* user_data Required (not null) The data to pass to callback. Returns: none	Gio.DBusConnection
	flush_finish (AsyncResult *res) : gboolean Finishes an operation started with g_dbus_connection_flush(). Finishes an operation started with g_dbus_connection_flush(). Parameters: Gio.AsyncResult res* Required (not null) A GAsyncResult obtained from the GAsyncReadyCallback passed to g_dbus_connection_flush(). Returns: gboolean TRUE if the operation succeeded, FALSE if error is set.	Gio.DBusConnection
	flush_sync (Cancellable *cancellable) : gboolean Synchronously flushes connection. Synchronously flushes connection. 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. Parameters: Gio.Cancellable cancellable* A GCancellable or NULL. Returns: gboolean TRUE if the operation succeeded, FALSE if error is set.	Gio.DBusConnection
	get_capabilities () : Gio.DBusCapabilityFlags Gets the capabilities negotiated with the remote peer Gets the capabilities negotiated with the remote peer Returns: Gio.DBusCapabilityFlags Zero or more flags from the GDBusCapabilityFlags enumeration.	Gio.DBusConnection
	get_exit_on_close () : gboolean Gets whether the process is terminated when connection is closed by the remote peer. Gets whether the process is terminated when connection is closed by the remote peer. See GDBusConnection:exit-on-close for more details. closed by the remote peer. Returns: gboolean Whether the process is terminated when connection is	Gio.DBusConnection
	get_guid () : String The GUID of the peer performing the role of server when authenticating. The GUID of the peer performing the role of server when authenticating. See GDBusConnection:guid for more details. Returns: String The GUID. Do not free this string, it is owned by	Gio.DBusConnection
	get_peer_credentials () : Gio.Credentials Gets the credentials of the authenticated peer. Gets the credentials of the authenticated peer. This will always return NULL unless connection acted as a server (e.g. G_DBUS_CONNECTION_FLAGS_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 NULL for message bus clients. this object, it is owned by connection. Returns: Gio.Credentials A GCredentials or NULL if not available. Do not free	Gio.DBusConnection
	get_stream () : Gio.IOStream Gets the underlying stream used for IO. Gets the underlying stream used for IO. Returns: Gio.IOStream the stream used for IO	Gio.DBusConnection
	get_unique_name () : String Gets the unique name of connection as assigned by the message bus. Gets the unique name of connection as assigned by the message bus. This can also be used to figure out if connection is a message bus connection. bus connection. Do not free this string, it is owned by Returns: String The unique name or NULL if connection is not a message	Gio.DBusConnection
	init (Cancellable *cancellable) : gboolean Initializes the object implementing the interface. Initializes the object implementing the interface. This must be done before any real use of the object after initial construction. Implementations may also support cancellation. If cancellable* is not NULL, then initialization can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error G_IO_ERROR_CANCELLED will be returned. If cancellable is not NULL and the object doesn't support cancellable initialization the error G_IO_ERROR_NOT_SUPPORTED will be returned. If this function is not called, or returns with an error then all operations on the object should fail, generally returning the error G_IO_ERROR_NOT_INITIALIZED. Implementations of this method must be idempotent, i.e. multiple calls to this function with the same argument should return the same results. Only the first call initializes the object, further calls return the result of the first call. This is so that its safe to implement the singleton pattern in the GObject constructor function. return FALSE and set error appropriately if present. Parameters: Gio.Cancellable cancellable optional GCancellable object, NULL to ignore. Returns: gboolean TRUE if successful. If an error has occurred, this function will	Gio.Initable
	init_async (gint32 *io_priority, Cancellable cancellable, Function callback, void *user_data) : none Starts asynchronous initialization of the object implementing the interface. Starts asynchronous initialization of the object implementing the interface. This must be done before any real use of the object after initial construction. If the object also implements GInitable* you can optionally call g_initable_init() instead. When the initialization is finished, callback will be called. You can then call g_async_initable_init_finish() to get the result of the initialization. Implementations may also support cancellation. If cancellable is not NULL, then initialization can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error G_IO_ERROR_CANCELLED will be returned. If cancellable is not NULL, and the object doesn't support cancellable initialization, the error G_IO_ERROR_NOT_SUPPORTED will be returned. If this function is not called, or returns with an error, then all operations on the object should fail, generally returning the error G_IO_ERROR_NOT_INITIALIZED. to this function with the same argument should return the same results. Only the first call initializes the object; further calls return the result of the first call. This is so that it's safe to implement the singleton pattern in the GObject constructor function. For classes that also support the GInitable interface, the default implementation of this method will run the g_initable_init() function in a thread, so if you want to support asynchronous initialization via threads, just implement the GAsyncInitable interface without overriding any interface methods. Parameters: gint32 io_priority Required (not null) the I/O priority of the operation. Gio.Cancellable cancellable optional GCancellable object, NULL to ignore. Function (Object *source_object, AsyncResult res, void *user_data) : none Required (not null) a GAsyncReadyCallback* to call when the request is satisfied void* user_data Required (not null) the data to pass to callback function Returns: none	Gio.AsyncInitable
	init_finish (AsyncResult *res) : gboolean Finishes asynchronous initialization and returns the result. Finishes asynchronous initialization and returns the result. See g_async_initable_init_async(). will return FALSE* and set error appropriately if present. Parameters: Gio.AsyncResult res Required (not null) a GAsyncResult. Returns: gboolean TRUE if successful. If an error has occurred, this function	Gio.AsyncInitable
	is_closed () : gboolean Gets whether connection is closed. Gets whether connection is closed. Returns: gboolean TRUE if the connection is closed, FALSE otherwise.	Gio.DBusConnection
	new_finish (AsyncResult *res) : GObject.Object Finishes the async construction for the various g_async_initable_new calls, returning the created object or NULL* on error. Finishes the async construction for the various g_async_initable_new calls, returning the created object or NULL on error. g_object_unref(). Parameters: Gio.AsyncResult res Required (not null) the GAsyncResult.from the callback Returns: GObject.Object a newly created GObject, or NULL on error. Free with	Gio.AsyncInitable
	register_object (String *object_path, DBusInterfaceInfo interface_info, DBusInterfaceVTable vtable, void *user_data, Function user_data_free_func) : guint32 Registers callbacks for exported objects at object_path* with the D-Bus interface that is described in interface_info. Registers callbacks for exported objects at object_path with the D-Bus interface that is described in interface_info. Calls to functions in vtable (and user_data_free_func) will happen in the thread-default main loop of the thread you are calling this method from. Note that all GVariant values passed to functions in vtable will match the signature given in interface_info - if a remote caller passes incorrect values, the org.freedesktop.DBus.Error.InvalidArgs is returned to the remote caller. Additionally, if the remote caller attempts to invoke methods or access properties not mentioned in interface_info the org.freedesktop.DBus.Error.UnknownMethod resp. org.freedesktop.DBus.Error.InvalidArgs errors are returned to the caller. It is considered a programming error if the GDBusInterfaceGetPropertyFunc function in vtable returns a GVariant of incorrect type. If an existing callback is already registered at object_path and GDBus automatically implements the standard D-Bus interfaces org.freedesktop.DBus.Properties, org.freedesktop.DBus.Introspectable and org.freedesktop.Peer, so you don't have to implement those for the objects you export. You can implement org.freedesktop.DBus.Properties yourself, e.g. to handle getting and setting of properties asynchronously. Note that the reference count on interface_info will be incremented by 1 (unless allocated statically, e.g. if the reference count is -1, see g_dbus_interface_info_ref()) for as long as the object is exported. Also note that vtable will be copied. See for an example of how to use this method. that can be used with g_dbus_connection_unregister_object() . Parameters: String object_path Required (not null) The object path to register at. Gio.DBusInterfaceInfo interface_info Required (not null) Introspection data for the interface. Gio.DBusInterfaceVTable vtable Required (not null) A GDBusInterfaceVTable to call into or NULL. void* user_data Required (not null) Data to pass to functions in vtable. Function (void* *data) : guint32 Required (not null) Function to call when the object path is unregistered. Returns: guint32 0 if error* is set, otherwise a registration id (never 0)	Gio.DBusConnection
	register_subtree (String *object_path, DBusSubtreeVTable vtable, DBusSubtreeFlags flags, void *user_data, Function user_data_free_func) : guint32 Registers a whole subtree of dynamic objects. Registers a whole subtree of dynamic objects. The enumerate* and introspection functions in vtable are used to convey, to remote callers, what nodes exist in the subtree rooted by object_path. When handling remote calls into any node in the subtree, first the or the G_DBUS_SUBTREE_FLAGS_DISPATCH_TO_UNENUMERATED_NODES flag is set the introspection function is used to check if the node supports the requested method. If so, the dispatch function is used to determine where to dispatch the call. The collected GDBusInterfaceVTable and gpointer will be used to call into the interface vtable for processing the request. All calls into user-provided code will be invoked in the linkend="g-main-context-push-thread-default">thread-default main loop of the thread you are calling this method from. If an existing subtree is already registered at object_path or then error is set to G_IO_ERROR_EXISTS. Note that it is valid to register regular objects (using g_dbus_connection_register_object()) in a subtree registered with g_dbus_connection_register_subtree() - if so, the subtree handler is tried as the last resort. One way to think about a subtree handler is to consider it a fallback handler for object paths not registered via g_dbus_connection_register_object() or other bindings. Note that vtable will be copied so you cannot change it after registration. See for an example of how to use this method. that can be used with g_dbus_connection_unregister_subtree() . Parameters: String object_path Required (not null) The object path to register the subtree at. Gio.DBusSubtreeVTable vtable Required (not null) A GDBusSubtreeVTable to enumerate, introspect and dispatch nodes in the subtree. Gio.DBusSubtreeFlags flags Required (not null) Flags used to fine tune the behavior of the subtree. void* user_data Required (not null) Data to pass to functions in vtable. Function (void* *data) : guint32 Required (not null) Function to call when the subtree is unregistered. Returns: guint32 0 if error* is set, otherwise a subtree registration id (never 0)	Gio.DBusConnection
	remove_filter (guint32 *filter_id) : none Removes a filter. Removes a filter. Parameters: guint32 filter_id* Required (not null) an identifier obtained from g_dbus_connection_add_filter() Returns: none	Gio.DBusConnection
	send_message (DBusMessage *message, DBusSendMessageFlags flags, guint32 out_serial) : gboolean Asynchronously sends message* to the peer represented by connection. Asynchronously sends message to the peer represented by connection. Unless flags contain the G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL flag, the serial number will be assigned by connection and set on message via g_dbus_message_set_serial(). If out_serial is not NULL, then the serial number used will be written to this location prior to submitting the message to the underlying transport. If connection is closed then the operation will fail with G_IO_ERROR_CLOSED. If message is not well-formed, the operation fails with G_IO_ERROR_INVALID_ARGUMENT. See and linkend="gdbus-unix-fd-client"/> 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 G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL flag. transmission, FALSE if error is set. Parameters: Gio.DBusMessage message Required (not null) A GDBusMessage Gio.DBusSendMessageFlags flags Required (not null) Flags affecting how the message is sent. guint32 out_serial Required (not null) Return location for serial number assigned to message when sending it or NULL. Returns: gboolean TRUE if the message was well-formed and queued for	Gio.DBusConnection
	send_message_with_reply (DBusMessage *message, DBusSendMessageFlags flags, gint32 timeout_msec, guint32 out_serial, Cancellable cancellable, Function callback, void *user_data) : none Asynchronously sends message* to the peer represented by connection. Asynchronously sends message to the peer represented by connection. Unless flags contain the G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL flag, the serial number will be assigned by connection and set on message via g_dbus_message_set_serial(). If out_serial is not NULL, then the serial number used will be written to this location prior to submitting the message to the underlying transport. If connection is closed then the operation will fail with G_IO_ERROR_CLOSED. If cancellable is canceled, the operation will fail with G_IO_ERROR_CANCELLED. If message is not well-formed, the operation fails with G_IO_ERROR_INVALID_ARGUMENT. This is an asynchronous method. When the operation is finished, callback will be invoked in the thread-default main loop 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 G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL flag. See and linkend="gdbus-unix-fd-client"/> for an example of how to use this low-level API to send and receive UNIX file descriptors. Parameters: Gio.DBusMessage message Required (not null) A GDBusMessage. Gio.DBusSendMessageFlags flags Required (not null) Flags affecting how the message is sent. gint32 timeout_msec Required (not null) The timeout in milliseconds, -1 to use the default timeout or G_MAXINT for no timeout. guint32 out_serial Required (not null) Return location for serial number assigned to message when sending it or NULL. Gio.Cancellable cancellable A GCancellable or NULL. Function (Object *source_object, AsyncResult res, void *user_data) : none Required (not null) A GAsyncReadyCallback* to call when the request is satisfied or NULL if you don't care about the result. void* user_data Required (not null) The data to pass to callback. Returns: none	Gio.DBusConnection
	send_message_with_reply_finish (AsyncResult *res) : Gio.DBusMessage Finishes an operation started with g_dbus_connection_send_message_with_reply(). Finishes an operation started with g_dbus_connection_send_message_with_reply(). Note that error* is only set if a local in-process error occured. That is to say that the returned GDBusMessage object may be of type G_DBUS_MESSAGE_TYPE_ERROR. Use g_dbus_message_to_gerror() to transcode this to a GError. See and linkend="gdbus-unix-fd-client"/> for an example of how to use this low-level API to send and receive UNIX file descriptors. Parameters: Gio.AsyncResult res Required (not null) A GAsyncResult obtained from the GAsyncReadyCallback passed to g_dbus_connection_send_message_with_reply(). Returns: Gio.DBusMessage A locked GDBusMessage or NULL if error is set.	Gio.DBusConnection
	send_message_with_reply_sync (DBusMessage *message, DBusSendMessageFlags flags, gint32 timeout_msec, guint32 out_serial, Cancellable cancellable) : Gio.DBusMessage Synchronously sends message* to the peer represented by connection and blocks the calling thread until a reply is received or the timeout is reached. Synchronously sends message to the peer represented by connection 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 G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL flag, the serial number will be assigned by connection and set on message via g_dbus_message_set_serial(). If out_serial is not NULL, then the serial number used will be written to this location prior to submitting the message to the underlying transport. If connection is closed then the operation will fail with G_IO_ERROR_CLOSED. If cancellable is canceled, the operation will fail with G_IO_ERROR_CANCELLED. If message is not well-formed, the operation fails with G_IO_ERROR_INVALID_ARGUMENT. Note that error is only set if a local in-process error occured. That is to say that the returned GDBusMessage object may be of type G_DBUS_MESSAGE_TYPE_ERROR. Use g_dbus_message_to_gerror() to transcode this to a GError. See and linkend="gdbus-unix-fd-client"/> 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 G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL flag. Parameters: Gio.DBusMessage message Required (not null) A GDBusMessage. Gio.DBusSendMessageFlags flags Required (not null) Flags affecting how the message is sent. gint32 timeout_msec Required (not null) The timeout in milliseconds, -1 to use the default timeout or G_MAXINT for no timeout. guint32 out_serial Required (not null) Return location for serial number assigned to message when sending it or NULL. Gio.Cancellable cancellable A GCancellable or NULL. Returns: Gio.DBusMessage A locked GDBusMessage that is the reply to message or NULL if error is set.	Gio.DBusConnection
	set_exit_on_close (gboolean *exit_on_close) : none Sets whether the process should be terminated when connection* is closed by the remote peer. Sets whether the process should be terminated when connection is closed by the remote peer. See GDBusConnection:exit-on-close for more details. Parameters: gboolean exit_on_close Required (not null) Whether the process should be terminated when connection is closed by the remote peer. Returns: none	Gio.DBusConnection
	signal_subscribe (String *sender, String interface_name, String member, String object_path, String arg0, DBusSignalFlags flags, Function callback, void *user_data, Function user_data_free_func) : guint32 Subscribes to signals on connection* and invokes callback with a whenever the signal is received. Subscribes to signals on connection and invokes callback with a whenever the signal is received. Note that callback will be invoked in the linkend="g-main-context-push-thread-default">thread-default main loop of the thread you are calling this method from. If connection is not a message bus connection, sender must be NULL. If sender is a well-known name note that callback is invoked with the unique name for the owner of sender, not the well-known name as one would expect. This is because the message bus rewrites the name. As such, to avoid certain race conditions, users should be tracking the name owner of the well-known name and use that when processing the received signal. Parameters: String sender Required (not null) Sender name to match on (unique or well-known name) or NULL to listen from all senders. String interface_name Required (not null) D-Bus interface name to match on or NULL to match on all interfaces. String member Required (not null) D-Bus signal name to match on or NULL to match on all signals. String object_path Required (not null) Object path to match on or NULL to match on all object paths. String arg0 Required (not null) Contents of first string argument to match on or NULL to match on all kinds of arguments. Gio.DBusSignalFlags flags Required (not null) Flags describing how to subscribe to the signal (currently unused). Function (DBusConnection *connection, String sender_name, String object_path, String interface_name, String signal_name, Variant parameters, void *user_data) : guint32 Required (not null) Callback to invoke when there is a signal matching the requested data. void user_data Required (not null) User data to pass to callback. Function (void* *data) : guint32 Required (not null) Function to free user_data* with when subscription is removed or NULL. Returns: guint32 A subscription identifier that can be used with g_dbus_connection_signal_unsubscribe().	Gio.DBusConnection
	signal_unsubscribe (guint32 *subscription_id) : none Unsubscribes from signals. Unsubscribes from signals. Parameters: guint32 subscription_id* Required (not null) A subscription id obtained from g_dbus_connection_signal_subscribe(). Returns: none	Gio.DBusConnection
	start_message_processing () : none If connection was created with G_DBUS_CONNECTION_FLAGS_DELAY_MESSAGE_PROCESSING, this method starts processing messages. If connection was created with G_DBUS_CONNECTION_FLAGS_DELAY_MESSAGE_PROCESSING, this method starts processing messages. Does nothing on if connection wasn't created with this flag or if the method has already been called. Returns: none	Gio.DBusConnection
	unregister_object (guint32 *registration_id) : gboolean Unregisters an object. Unregisters an object. Parameters: guint32 registration_id* Required (not null) A registration id obtained from g_dbus_connection_register_object(). Returns: gboolean TRUE if the object was unregistered, FALSE otherwise.	Gio.DBusConnection
	unregister_subtree (guint32 *registration_id) : gboolean Unregisters a subtree. Unregisters a subtree. Parameters: guint32 registration_id* Required (not null) A subtree registration id obtained from g_dbus_connection_register_subtree(). Returns: gboolean TRUE if the subtree was unregistered, FALSE otherwise.	Gio.DBusConnection

Events - usage syntax: this.signals.EVENTNAME.connect( Function )
Event		Defined By
	closed (DBusConnection *self, gboolean remote_peer_vanished, Error error) : none Emitted when the connection is closed. Emitted when the connection is closed. The cause of this event can be If g_dbus_connection_close() is called. In this case If the remote peer closes the connection. In this case 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 once. Parameters: Gio.DBusConnection self gboolean remote_peer_vanished GObject.Error error Returns: {none}	Gio.DBusConnection

Used by These Methods / Signals / Properties
Class / Namespace	Method / Signal / Properties
Gio Method	Gio.bus_get_finish (AsyncResult *res*) : Gio.DBusConnection Finishes an operation started with g_bus_get().
Gio Method	Gio.bus_get_sync (BusType *bus_type, Cancellable cancellable) : Gio.DBusConnection Synchronously connects to the message bus specified by bus_type*.
Gio Method	Gio.bus_own_name_on_connection (DBusConnection *connection, String name, BusNameOwnerFlags flags, Closure name_acquired_closure, Closure name_lost_closure) : guint32 Like g_bus_own_name() but takes a GDBusConnection* instead of a GBusType.
Gio Method	Gio.bus_watch_name_on_connection (DBusConnection *connection, String name, BusNameWatcherFlags flags, Closure name_appeared_closure, Closure name_vanished_closure) : guint32 Like g_bus_watch_name() but takes a GDBusConnection* instead of a GBusType.
Gio.DBusMethodInvocation Method	get_connection () : Gio.DBusConnection Gets the GDBusConnection the method was invoked on.
Gio.DBusProxy Property	g_connection : Gio.DBusConnection The GDBusConnection the proxy is for.
Gio.DBusProxy Method	new Gio.DBusProxy.sync (DBusConnection *connection, DBusProxyFlags flags, DBusInterfaceInfo info, String name, String object_path, String interface_name, Cancellable cancellable*) : Gio.DBusProxy Create a new Gio.DBusProxy
Gio.DBusProxy Method	Gio.DBusProxy.c_new (DBusConnection *connection, DBusProxyFlags flags, DBusInterfaceInfo info, String name, String object_path, String interface_name, Cancellable cancellable, Function callback, void *user_data) : none Creates a proxy for accessing interface_name* on the remote object at object_path owned by name at connection and asynchronously loads D-Bus properties unless the G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES flag is used.
Gio.DBusProxy Method	get_connection () : Gio.DBusConnection Gets the connection proxy is for.
Gio.DBusServer Signal	new_connection (DBusServer *self, DBusConnection connection*) : gboolean Emitted when a new authenticated connection has been made.