D-Bus GLib bindings - Reference Manual |
|---|
for version 0.112
dbus-glib is a deprecated API for use of D-Bus from GLib applications. Do not use it in new code.
Since version 2.26, GLib's accompanying GIO library provides a high-level API for D-Bus, "GDBus", based on an independent reimplementation of the D-Bus protocol. The maintainers of D-Bus recommend that GLib applications should use GDBus instead of dbus-glib.
| Top | |
|
|
|
| DBusGTypeSpecializedAppendContext | |
| DBusGTypeSpecializedVtable | |
| DBusGTypeSpecializedCollectionVtable | |
| DBusGTypeSpecializedMapVtable | |
| DBusGTypeSpecializedStructVtable | |
| #define | DBUS_TYPE_G_BOOLEAN_ARRAY |
| #define | DBUS_TYPE_G_UCHAR_ARRAY |
| #define | DBUS_TYPE_G_UINT_ARRAY |
| #define | DBUS_TYPE_G_INT_ARRAY |
| #define | DBUS_TYPE_G_UINT64_ARRAY |
| #define | DBUS_TYPE_G_INT64_ARRAY |
| #define | DBUS_TYPE_G_OBJECT_ARRAY |
| #define | DBUS_TYPE_G_STRING_STRING_HASHTABLE |
| typedef | DBusGSignature |
| #define | DBUS_TYPE_G_SIGNATURE |
| typedef | DBusGObjectPath |
| #define | DBUS_TYPE_G_OBJECT_PATH |
Specialized gtypes are basically a way to allow the definition of recursive GTypes. It allows the definition of 'containers' which is basically a user defined structure capable of holding other data, and a set of functions defining how to access that structure. Containers come in 3 flavors: collections, maps and structs.
A collection is a container that holds an ordered set of items, all of which must be the same type. (This is an array in standard D-Bus terminology.) dbus-glib specialized collections can be GArray (for numeric elements), GPtrArray (for string, object or boxed elements), GSList (for boxed elements, not recommended), or a user-defined type.
A map is a container that holds a set of key/value pairs. The keys have one type, and the values another; the type of the keys must be a numeric or string-like type. (This is a dict (dictionary) or array of dict entry in standard D-Bus terminology.) dbus-glib specialized maps can be GHashTable or a user-defined type.
A struct is a container that holds a fixed number of members, each member
having a predefined type. (This is a struct in
standard D-Bus terminology.) It is analogous to the C struct
keyword, but
dbus-glib does not generally represent D-Bus structs in C structs.
dbus-glib specialized structs can be GValueArray or a user-defined type.
A specialization is a GType detailing a particular container with particular types (a type specialization).
Functions are provided for constructing and manipulating specializations.
This documentation needs splitting into two pages, one for defining new containers and using existing containers. I expect most users to only do the latter. I also need to add some examples.
void (*DBusGTypeSpecializedCollectionIterator) (const GValue *value,gpointer user_data);
DBusGTypeSpecializedCollectionIterator is deprecated and should not be used in newly-written code.
New code should use GDBus instead.
A library-user-supplied function, called for each element in the
collection when dbus_g_type_collection_value_iterate() is called.
value |
an element of the collection |
|
user_data |
the data supplied when calling
|
void (*DBusGTypeSpecializedMapIterator) (const GValue *key_val,const GValue *value_val,gpointer user_data);
DBusGTypeSpecializedMapIterator is deprecated and should not be used in newly-written code.
New code should use GDBus instead.
A library-user-supplied function, called for each key/value pair in the
collection when dbus_g_type_map_value_iterate() is called.
key_val |
a key from the map |
|
value_val |
a value from the map |
|
user_data |
the data supplied when calling
|
gpointer
(*DBusGTypeSpecializedConstructor) (GType type);
DBusGTypeSpecializedConstructor is deprecated and should not be used in newly-written code.
New code should use GDBus instead.
void (*DBusGTypeSpecializedFreeFunc) (GType type,gpointer val);
DBusGTypeSpecializedFreeFunc is deprecated and should not be used in newly-written code.
New code should use GDBus instead.
Frees val
according to type
. This is analogous to GBoxedFreeFunc, but
can use information from type
(for instance to free the contents of a
container before freeing the actual container).
gpointer (*DBusGTypeSpecializedCopyFunc) (GType type,gpointer src);
DBusGTypeSpecializedCopyFunc is deprecated and should not be used in newly-written code.
New code should use GDBus instead.
Copies src
according to type
. This is analogous to GBoxedCopyFunc, but
can use information from type
(for instance to copy each element of a
collection).
gboolean (*DBusGTypeSpecializedCollectionFixedAccessorFunc) (GType type,gpointer instance,gpointer *values,guint *len);
DBusGTypeSpecializedCollectionFixedAccessorFunc is deprecated and should not be used in newly-written code.
New code should use GDBus instead.
Implements dbus_g_type_collection_get_fixed() for a GValue with type
type
, containing instance
.
void (*DBusGTypeSpecializedCollectionIteratorFunc) (GType type,gpointer instance,DBusGTypeSpecializedCollectionIterator iterator,gpointer user_data);
DBusGTypeSpecializedCollectionIteratorFunc is deprecated and should not be used in newly-written code.
New code should use GDBus instead.
Implements dbus_g_type_collection_value_iterate() for a GValue with
type type
, containing instance
.
void (*DBusGTypeSpecializedCollectionAppendFunc) (DBusGTypeSpecializedAppendContext *ctx,GValue *val);
DBusGTypeSpecializedCollectionAppendFunc is deprecated and should not be used in newly-written code.
New code should use GDBus instead.
Implements dbus_g_type_specialized_collection_append().
This function should use the val
and specialization_type
members of ctx
.
ctx |
an appending context returned by |
|
val |
a value to copy into the collection |
void
(*DBusGTypeSpecializedCollectionEndAppendFunc)
(DBusGTypeSpecializedAppendContext *ctx);
DBusGTypeSpecializedCollectionEndAppendFunc is deprecated and should not be used in newly-written code.
New code should use GDBus instead.
Implements dbus_g_type_specialized_collection_end_append().
This function should use the val
and specialization_type
members of ctx
.
void (*DBusGTypeSpecializedMapIteratorFunc) (GType type,gpointer instance,DBusGTypeSpecializedMapIterator iterator,gpointer user_data);
DBusGTypeSpecializedMapIteratorFunc is deprecated and should not be used in newly-written code.
New code should use GDBus instead.
Implements dbus_g_type_map_value_iterate() for a GValue with
type type
, containing instance
.
void (*DBusGTypeSpecializedMapAppendFunc) (DBusGTypeSpecializedAppendContext *ctx,GValue *key,GValue *val);
DBusGTypeSpecializedMapAppendFunc is deprecated and should not be used in newly-written code.
New code should use GDBus instead.
Implements dbus_g_type_specialized_map_append().
This function should use the val
and specialization_type
members of ctx
,
and replace any existing value with key equal to key
.
ctx |
an appending context returned by |
|
key |
a key to add to the collection |
|
val |
a value to add to the collection |
gboolean (*DBusGTypeSpecializedStructGetMember) (GType type,gpointer instance,guint member,GValue *ret_value);
DBusGTypeSpecializedStructGetMember is deprecated and should not be used in newly-written code.
New code should use GDBus instead.
Implements dbus_g_type_struct_get_member() for a GValue with type type
,
containing instance
.
type |
a specialized struct boxed type |
|
instance |
an instance of |
|
member |
the index of the member, starting from 0 |
|
ret_value |
an initialized GValue of the appropriate type for the given
member of |
gboolean (*DBusGTypeSpecializedStructSetMember) (GType type,gpointer instance,guint member,const GValue *new_value);
DBusGTypeSpecializedStructSetMember is deprecated and should not be used in newly-written code.
New code should use GDBus instead.
Implements dbus_g_type_struct_set_member() for a GValue with type type
,
containing instance
.
type |
a specialized struct boxed type |
|
instance |
an instance of |
|
member |
the index of the member, starting from 0 |
|
new_value |
an initialized GValue of the appropriate type for the given
member of |
GType dbus_g_type_get_collection (const char *container,GType specialization);
dbus_g_type_get_collection is deprecated and should not be used in newly-written code.
New code should use GDBus instead.
Gets a GType for a particular collection instance, creating the type if not already created.
container |
a string specifying a registered collection type |
|
specialization |
GType of collection elements |
GType dbus_g_type_get_map (const char *container,GType key_specialization,GType value_specialization);
dbus_g_type_get_map is deprecated and should not be used in newly-written code.
New code should use GDBus instead.
Gets a GType for a particular map instance, creating the type if not already created.
GType dbus_g_type_get_structv (const char *container,guint num_members,GType *types);
dbus_g_type_get_structv is deprecated and should not be used in newly-written code.
New code should use GDBus instead.
Gets a GType for a particular struct instance, creating the type if not already created.
GType dbus_g_type_get_struct (const char *container,GType first_type,...);
dbus_g_type_get_struct is deprecated and should not be used in newly-written code.
New code should use GDBus instead.
Varags method to get a GType for a particular struct instance, creating the type if not already created.
container |
a string specifying a registered struct type |
|
first_type |
GType for the struct's first member |
|
... |
more GTypes for the struct's members, terminated by G_TYPE_INVALID |
gboolean
dbus_g_type_is_collection (GType gtype);
dbus_g_type_is_collection is deprecated and should not be used in newly-written code.
New code should use GDBus instead.
Tests if a given GType is a collection.
gboolean
dbus_g_type_is_map (GType gtype);
dbus_g_type_is_map is deprecated and should not be used in newly-written code.
New code should use GDBus instead.
Tests if a given GType is a map,
i.e. it was created with dbus_g_type_get_map().
gboolean
dbus_g_type_is_struct (GType gtype);
dbus_g_type_is_struct is deprecated and should not be used in newly-written code.
New code should use GDBus instead.
Tests if a given GType is a struct,
i.e. it was created with dbus_g_type_get_struct()
GType
dbus_g_type_get_collection_specialization
(GType gtype);
dbus_g_type_get_collection_specialization is deprecated and should not be used in newly-written code.
New code should use GDBus instead.
Return the type of each element in collections of type gtype
.
It is an error to call this function on a non-collection type.
GType
dbus_g_type_get_map_key_specialization
(GType gtype);
dbus_g_type_get_map_key_specialization is deprecated and should not be used in newly-written code.
New code should use GDBus instead.
Return the type of the keys in maps of type gtype
.
It is an error to call this function on a non-map type.
GType
dbus_g_type_get_map_value_specialization
(GType gtype);
dbus_g_type_get_map_value_specialization is deprecated and should not be used in newly-written code.
New code should use GDBus instead.
Return the type of the values in maps of type gtype
.
It is an error to call this function on a non-map type.
GType dbus_g_type_get_struct_member_type (GType gtype,guint member);
dbus_g_type_get_struct_member_type is deprecated and should not be used in newly-written code.
New code should use GDBus instead.
Get the type of a member of a specialized struct. It is an error to call this function on a non-struct type.
gtype |
a struct GType, as created with |
|
member |
the index of a struct member |
the type for a given member of a struct GType,
or G_TYPE_INVALID if member
>= dbus_g_type_get_struct_size()
guint
dbus_g_type_get_struct_size (GType gtype);
dbus_g_type_get_struct_size is deprecated and should not be used in newly-written code.
New code should use GDBus instead.
Get the number of members in a specialized struct. It is an error to call this function on a non-struct type.
gpointer
dbus_g_type_specialized_construct (GType gtype);
dbus_g_type_specialized_construct is deprecated and should not be used in newly-written code.
New code should use GDBus instead.
Create an instance of a given specialized type. The structure created and returned will depend on the container type of the GType. E.g. If the given type was created by dbus_g_type_get_collection("GArray", G_TYPE_INT), then this will return a GArray with element_size of sizeof(int)
gtype |
a specialized GType, as created by |
void dbus_g_type_specialized_init_append (GValue *value,DBusGTypeSpecializedAppendContext *ctx);
dbus_g_type_specialized_init_append is deprecated and should not be used in newly-written code.
New code should use GDBus instead.
Create a new context for adding elements to a collection or key/value pairs to a map. You generally don't need or want to use this..
value |
a GValue containing an instance of specialized type |
|
ctx |
a DBusGTypeSpecializedAppendContext in which to return a new appending context. |
void dbus_g_type_specialized_collection_append (DBusGTypeSpecializedAppendContext *ctx,GValue *elt);
dbus_g_type_specialized_collection_append is deprecated and should not be used in newly-written code.
New code should use GDBus instead.
Appends a given element to the end of a collection.
ctx |
a context created by |
|
elt |
a GValue containing an element to append to the collection |
void
dbus_g_type_specialized_collection_end_append
(DBusGTypeSpecializedAppendContext *ctx);
dbus_g_type_specialized_collection_end_append is deprecated and should not be used in newly-written code.
New code should use GDBus instead.
Finish appending elements to a given collection
ctx |
a context created by |
void dbus_g_type_specialized_map_append (DBusGTypeSpecializedAppendContext *ctx,GValue *key,GValue *val);
dbus_g_type_specialized_map_append is deprecated and should not be used in newly-written code.
New code should use GDBus instead.
Inserts the given key/value pair into the map instance.
ctx |
a context created by |
|
key |
a GValue containing a key, whose contents will be stolen by |
|
val |
a GValue containing a value, whose contents will be stolen by |
gboolean dbus_g_type_collection_get_fixed (GValue *value,gpointer *data_ret,guint *len_ret);
dbus_g_type_collection_get_fixed is deprecated and should not be used in newly-written code.
New code should use GDBus instead.
Calling this function is likely to be a bad idea. Consider using
dbus_g_type_collection_value_iterate() instead.
On success, data_ret
is a pointer to the underlying data in a collection
of fixed-length fundamental types. Knowledge of the underlying data model
of the collection is needed in order to use data_ret
correctly.
It is an error to call this function on a specialized type that is not a
collection, or on a collection that does not have a fixed_accessor
in its
DBusGTypeSpecializedCollectionVtable.
Specialized GArrays are the only types provided by dbus-glib that can be used with this function; user-defined types might also work.
value |
a GValue containing a boxed specialized collection
that has a |
|
data_ret |
used to return a pointer to the fixed data, which must not be modified (for instance, for a GArray of gint, this would point to an array of gint) |
|
len_ret |
used to return the length (counting collection elements, not bytes: in a GArray containing one gint, this would be 1) |
void dbus_g_type_collection_value_iterate (const GValue *value,DBusGTypeSpecializedCollectionIterator iterator,gpointer user_data);
dbus_g_type_collection_value_iterate is deprecated and should not be used in newly-written code.
New code should use GDBus instead.
Calls the given function for each element of the collection.
The function is passed a GValue containing the element and the given
user_data
parameter. The collection may not be modified while iterating over
it.
value |
a GValue holding a collection type. |
|
iterator |
a function to call for each element |
|
user_data |
user data to pass to the |
void dbus_g_type_map_value_iterate (const GValue *value,DBusGTypeSpecializedMapIterator iterator,gpointer user_data);
dbus_g_type_map_value_iterate is deprecated and should not be used in newly-written code.
New code should use GDBus instead.
Calls the given function for each key/value pair of the map.
The function is passed two GValues containing the key/value pair and the given
user_data
parameter. The map may not be modified while iterating over
it.
value |
a GValue holding a specialized map |
|
iterator |
a function to call for each element |
|
user_data |
user data to pass to the |
gboolean dbus_g_type_struct_get_member (const GValue *value,guint member,GValue *dest);
dbus_g_type_struct_get_member is deprecated and should not be used in newly-written code.
New code should use GDBus instead.
Fetches a given member of a given struct instance. dest
must be initialised
was the correct type for that member, e.g. as returned by
dbus_g_type_get_struct_member_type
gboolean dbus_g_type_struct_set_member (GValue *value,guint member,const GValue *src);
dbus_g_type_struct_set_member is deprecated and should not be used in newly-written code.
New code should use GDBus instead.
Sets a given member of a struct to a new value. The type of src
must match
the existing type of member
member of the struct.
gboolean dbus_g_type_struct_get (const GValue *value,guint member,...);
dbus_g_type_struct_get is deprecated and should not be used in newly-written code.
New code should use GDBus instead.
Collects the selected values of this struct into the return locations provided.
gboolean dbus_g_type_struct_set (GValue *value,guint member,...);
dbus_g_type_struct_set is deprecated and should not be used in newly-written code.
New code should use GDBus instead.
Sets the selected members of the struct in value
.
void
dbus_g_type_specialized_init (void);
dbus_g_type_specialized_init is deprecated and should not be used in newly-written code.
New code should use GDBus instead.
Initialize dbus-glib specialized GTypes.
In older versions of dbus-glib, it was necessary to do this before instantiating or registering any specialized type. It is now done automatically whenever necessary.
void dbus_g_type_register_collection (const char *name,const DBusGTypeSpecializedCollectionVtable *vtable,guint flags);
dbus_g_type_register_collection is deprecated and should not be used in newly-written code.
New code should use GDBus instead.
Defines a new collection container.
void dbus_g_type_register_map (const char *name,const DBusGTypeSpecializedMapVtable *vtable,guint flags);
dbus_g_type_register_map is deprecated and should not be used in newly-written code.
New code should use GDBus instead.
Defines a new map container.
const DBusGTypeSpecializedMapVtable *
dbus_g_type_map_peek_vtable (GType map_type);
dbus_g_type_map_peek_vtable is deprecated and should not be used in newly-written code.
New code should use GDBus instead.
Peek the vtable for a given map specialization
const DBusGTypeSpecializedCollectionVtable *
dbus_g_type_collection_peek_vtable (GType collection_type);
dbus_g_type_collection_peek_vtable is deprecated and should not be used in newly-written code.
New code should use GDBus instead.
Peek the vtable for a given collection specialization
const DBusGTypeSpecializedStructVtable *
dbus_g_type_struct_peek_vtable (GType struct_type);
dbus_g_type_struct_peek_vtable is deprecated and should not be used in newly-written code.
New code should use GDBus instead.
Peek the vtable for a given struct specialization
void dbus_g_type_register_struct (const char *name,const DBusGTypeSpecializedStructVtable *vtable,guint flags);
dbus_g_type_register_struct is deprecated and should not be used in newly-written code.
New code should use GDBus instead.
Defines a new struct container.
GVariant *
dbus_g_value_build_g_variant (const GValue *value);
dbus_g_value_build_g_variant is deprecated and should not be used in newly-written code.
New code should use GDBus instead.
Recurses value
and converts its contents to a GVariant.
The value must either be a simple value (integer, string, boolean,
object path etc.) or a specialized container registered with
dbus_g_type_get_collection(), dbus_g_type_get_map() or
dbus_g_type_get_struct(). Providing any other type is a programming error
(including as a child type).
void dbus_g_value_parse_g_variant (GVariant *variant,GValue *value);
dbus_g_value_parse_g_variant is deprecated and should not be used in newly-written code.
New code should use GDBus instead.
Deserialize variant
and put an equivalent dbus-glib data structure in
value
.
It is an error if variant
contains any GVariant extensions not supported
by dbus-glib, including handles (file descriptor passing) and 'maybe' types.
typedef struct {
/* public */
GValue *val;
GType specialization_type;
} DBusGTypeSpecializedAppendContext;
DBusGTypeSpecializedAppendContext is deprecated and should not be used in newly-written code.
New code should use GDBus instead.
A context for appending. There are more fields, which are private.
typedef struct {
DBusGTypeSpecializedConstructor constructor;
DBusGTypeSpecializedFreeFunc free_func;
DBusGTypeSpecializedCopyFunc copy_func;
GDestroyNotify simple_free_func; /* for type-independent freeing if possible */
} DBusGTypeSpecializedVtable;
DBusGTypeSpecializedVtable is deprecated and should not be used in newly-written code.
New code should use GDBus instead.
A table of methods used to implement specialized container behaviour on
user-defined collections, maps and structs. Exactly one of free_func
and
simple_free_func
must be implemented; the other must be NULL.
constructor
and copy_func
must always be implemented.
There are additional members, which are reserved for future expansion and
must be NULL.
DBusGTypeSpecializedConstructor |
returns a new, blank instance of the |
|
DBusGTypeSpecializedFreeFunc |
if not |
|
DBusGTypeSpecializedCopyFunc |
returns a "deep copy" of the |
|
GDestroyNotify |
if not |
typedef struct {
DBusGTypeSpecializedVtable base_vtable;
DBusGTypeSpecializedCollectionFixedAccessorFunc fixed_accessor;
DBusGTypeSpecializedCollectionIteratorFunc iterator;
DBusGTypeSpecializedCollectionAppendFunc append_func;
DBusGTypeSpecializedCollectionEndAppendFunc end_append_func;
} DBusGTypeSpecializedCollectionVtable;
DBusGTypeSpecializedCollectionVtable is deprecated and should not be used in newly-written code.
New code should use GDBus instead.
A table of methods used to implement specialized collection behaviour
on user-defined types. At least iterator
and append_func
must be
implemented.
DBusGTypeSpecializedVtable |
base methods shared between collections and other types |
|
DBusGTypeSpecializedCollectionFixedAccessorFunc |
if not |
|
iterates through the members of |
||
DBusGTypeSpecializedCollectionAppendFunc |
appends a new member to |
|
DBusGTypeSpecializedCollectionEndAppendFunc |
if not |
typedef struct {
DBusGTypeSpecializedVtable base_vtable;
DBusGTypeSpecializedMapIteratorFunc iterator;
DBusGTypeSpecializedMapAppendFunc append_func;
} DBusGTypeSpecializedMapVtable;
DBusGTypeSpecializedMapVtable is deprecated and should not be used in newly-written code.
New code should use GDBus instead.
A table of methods used to implement specialized collection behaviour on user-defined types. Both methods must be implemented.
DBusGTypeSpecializedVtable |
base methods shared between maps and other types |
|
DBusGTypeSpecializedMapIteratorFunc |
iterates through the members of |
|
DBusGTypeSpecializedMapAppendFunc |
adds a new key/value pair to |
typedef struct {
DBusGTypeSpecializedVtable base_vtable;
DBusGTypeSpecializedStructGetMember get_member;
DBusGTypeSpecializedStructSetMember set_member;
} DBusGTypeSpecializedStructVtable;
DBusGTypeSpecializedStructVtable is deprecated and should not be used in newly-written code.
New code should use GDBus instead.
A table of methods used to implement specialized collection behaviour on user-defined types. Both methods must be implemented.
DBusGTypeSpecializedVtable |
base methods shared between maps and other types |
|
DBusGTypeSpecializedStructGetMember |
returns a member by its index |
|
DBusGTypeSpecializedStructSetMember |
sets a member by its index |
#define DBUS_TYPE_G_BOOLEAN_ARRAY (dbus_g_type_get_collection ("GArray", G_TYPE_BOOLEAN))
DBUS_TYPE_G_BOOLEAN_ARRAY is deprecated and should not be used in newly-written code.
New code should use GDBus instead. The closest equivalent
is G_VARIANT_TYPE ("ab").
Expands to a function call returning the GType of a GArray of gboolean (corresponding to the D-Bus signature "ab").
#define DBUS_TYPE_G_UCHAR_ARRAY (dbus_g_type_get_collection ("GArray", G_TYPE_UCHAR))
DBUS_TYPE_G_UCHAR_ARRAY is deprecated and should not be used in newly-written code.
New code should use GDBus instead. The closest equivalent
is G_VARIANT_TYPE_BYTESTRING.
Expands to a function call returning the GType of a GArray of guchar (corresponding to the D-Bus signature "ay").
Note that this is not the same thing as a GByteArray! dbus-glib does not know about the GByteArray type.
#define DBUS_TYPE_G_UINT_ARRAY (dbus_g_type_get_collection ("GArray", G_TYPE_UINT))
DBUS_TYPE_G_UINT_ARRAY is deprecated and should not be used in newly-written code.
New code should use GDBus instead. The closest equivalent
is G_VARIANT_TYPE ("au").
Expands to a function call returning the GType of a GArray of guint (corresponding to the D-Bus signature "au").
#define DBUS_TYPE_G_INT_ARRAY (dbus_g_type_get_collection ("GArray", G_TYPE_INT))
DBUS_TYPE_G_INT_ARRAY is deprecated and should not be used in newly-written code.
New code should use GDBus instead. The closest equivalent
is G_VARIANT_TYPE ("ai").
Expands to a function call returning the GType of a GArray of gint (corresponding to the D-Bus signature "ai").
#define DBUS_TYPE_G_UINT64_ARRAY (dbus_g_type_get_collection ("GArray", G_TYPE_UINT64))
DBUS_TYPE_G_UINT64_ARRAY is deprecated and should not be used in newly-written code.
New code should use GDBus instead. The closest equivalent
is G_VARIANT_TYPE ("at").
Expands to a function call returning the GType of a GArray of guint64 (corresponding to the D-Bus signature "at").
#define DBUS_TYPE_G_INT64_ARRAY (dbus_g_type_get_collection ("GArray", G_TYPE_INT64))
DBUS_TYPE_G_INT64_ARRAY is deprecated and should not be used in newly-written code.
New code should use GDBus instead. The closest equivalent
is G_VARIANT_TYPE ("ax").
Expands to a function call returning the GType of a GArray of gint64 (corresponding to the D-Bus signature "ax").
#define DBUS_TYPE_G_OBJECT_ARRAY (dbus_g_type_get_collection ("GPtrArray", G_TYPE_OBJECT))
DBUS_TYPE_G_OBJECT_ARRAY is deprecated and should not be used in newly-written code.
New code should use GDBus instead. The closest equivalent
is G_VARIANT_TYPE_OBJECT_PATH_ARRAY.
Expands to a function call returning the GType of a GPtrArray of GObject.
Use this type with caution: it can sometimes be used as a representation
of arrays whose D-Bus signature is "ao" (transferred as an array of object
paths), but the conventional type for such arrays is
(dbus_g_type_get_collection ("GPtrArray",
DBUS_TYPE_G_OBJECT_PATH)).
#define DBUS_TYPE_G_STRING_STRING_HASHTABLE (dbus_g_type_get_map ("GHashTable", G_TYPE_STRING, G_TYPE_STRING))
DBUS_TYPE_G_STRING_STRING_HASHTABLE is deprecated and should not be used in newly-written code.
New code should use GDBus instead. The closest equivalent
is G_VARIANT_TYPE ("a{ss}").
Expands to a function call returning the GType of a GHashTable where the keys are strings and the values are also strings (corresponding to the D-Bus signature "a{ss}").
typedef gchar DBusGSignature;
DBusGSignature is deprecated and should not be used in newly-written code.
New code should use GDBus instead. The closest equivalent
is a GVariant (G_TYPE_VARIANT) of type G_VARIANT_TYPE_SIGNATURE.
A typedef for a string used to represent D-Bus signatures.
Its GType is DBUS_TYPE_G_SIGNATURE, derived from G_TYPE_BOXED.
Prior to version 0.FIXME this was used as the type name of
DBUS_TYPE_G_SIGNATURE, but did not actually exist as a typedef.
Since: 0.FIXME
#define DBUS_TYPE_G_SIGNATURE (dbus_g_signature_get_g_type ())
DBUS_TYPE_G_SIGNATURE is deprecated and should not be used in newly-written code.
New code should use GDBus instead. The closest equivalent
is a GVariant (G_TYPE_VARIANT) of type G_VARIANT_TYPE_SIGNATURE.
The GType of a DBusGSignature, which is a boxed type containing a
D-Bus signature as a zero-terminated string. Signatures can be
copied with g_strdup() and freed with g_free(), just like G_TYPE_STRING,
but have a distinct boxed type to allow them to be distinguished when
stored in a GValue.
typedef gchar DBusGObjectPath;
DBusGObjectPath is deprecated and should not be used in newly-written code.
New code should use GDBus instead. The closest equivalent
is a GVariant (G_TYPE_VARIANT) of type G_VARIANT_TYPE_OBJECT_PATH.
A typedef for a string used to represent D-Bus object paths.
Its GType is DBUS_TYPE_G_OBJECT_PATH, derived from G_TYPE_BOXED.
Prior to version 0.FIXME this was used as the type name of
DBUS_TYPE_G_OBJECT_PATH, but did not actually exist as a typedef.
Since: 0.FIXME
#define DBUS_TYPE_G_OBJECT_PATH (dbus_g_object_path_get_g_type ())
DBUS_TYPE_G_OBJECT_PATH is deprecated and should not be used in newly-written code.
New code should use GDBus instead. The closest equivalent
is a GVariant (G_TYPE_VARIANT) of type G_VARIANT_TYPE_OBJECT_PATH.
The GType of a DBusGObjectPath, which is a boxed type containing a
D-Bus object path as a zero-terminated string. Object paths can be
copied with g_strdup() and freed with g_free(), just like G_TYPE_STRING,
but have a distinct boxed type to allow them to be distinguished when
stored in a GValue.
| Top | |
|
|
|
| void | (*DBusGProxyCallNotify) () |
| DBusGProxy * | dbus_g_proxy_new_for_name () |
| DBusGProxy * | dbus_g_proxy_new_for_name_owner () |
| DBusGProxy * | dbus_g_proxy_new_from_proxy () |
| DBusGProxy * | dbus_g_proxy_new_for_peer () |
| void | dbus_g_proxy_set_interface () |
| const char * | dbus_g_proxy_get_path () |
| const char * | dbus_g_proxy_get_bus_name () |
| const char * | dbus_g_proxy_get_interface () |
| void | dbus_g_proxy_add_signal () |
| void | dbus_g_proxy_connect_signal () |
| void | dbus_g_proxy_disconnect_signal () |
| void | dbus_g_proxy_send () |
| gboolean | dbus_g_proxy_call () |
| gboolean | dbus_g_proxy_call_with_timeout () |
| void | dbus_g_proxy_call_no_reply () |
| DBusGProxyCall * | dbus_g_proxy_begin_call () |
| DBusGProxyCall * | dbus_g_proxy_begin_call_with_timeout () |
| gboolean | dbus_g_proxy_end_call () |
| void | dbus_g_proxy_cancel_call () |
| void | dbus_g_proxy_set_default_timeout () |
void (*DBusGProxyCallNotify) (DBusGProxy *proxy,DBusGProxyCall *call_id,void *user_data);
DBusGProxyCallNotify is deprecated and should not be used in newly-written code.
New code should use GDBus instead. The closest equivalent is the standard GAsyncReadyCallback mechanism.
Called when a reply to the call represented by call_id
arrives.
Use dbus_g_proxy_end_call() to see whether call_id
succeeded or
failed, and get the arguments returned (if any) on success.
proxy |
the proxy on which the method was called |
|
call_id |
the call in progress |
|
user_data |
data passed to |
DBusGProxy * dbus_g_proxy_new_for_name (DBusGConnection *connection,const char *name,const char *path,const char *iface);
dbus_g_proxy_new_for_name is deprecated and should not be used in newly-written code.
New code should use GDBus instead. The closest equivalent
is g_dbus_proxy_new_sync().
Creates a new proxy for a remote interface exported by a connection
on a message bus. Method calls and signal connections over this
proxy will go to the name owner; the name's owner is expected to
support the given interface name. THE NAME OWNER MAY CHANGE OVER
TIME, for example between two different method calls, unless the
name is a unique name. If you need a fixed owner, you need to
request the current owner and bind a proxy to its unique name
rather than to the generic name; see
dbus_g_proxy_new_for_name_owner().
A name-associated proxy only makes sense with a message bus, not for app-to-app direct dbus connections.
This proxy will only emit the "destroy" signal if the DBusConnection is disconnected, the proxy has no remaining references, or the name is a unique name and its owner disappears. If a well-known name changes owner, the proxy will still be alive.
DBusGProxy * dbus_g_proxy_new_for_name_owner (DBusGConnection *connection,const char *name,const char *path,const char *iface,GError **error);
dbus_g_proxy_new_for_name_owner is deprecated and should not be used in newly-written code.
New code should use GDBus instead. The closest equivalent
is g_dbus_proxy_new_sync() with the name owner's unique name
passed as name
.
Similar to dbus_g_proxy_new_for_name(), but makes a round-trip
request to the message bus to get the current name owner, then
binds the proxy to the unique name of the current owner, rather
than to the well-known name. As a result, the name owner will
not change over time, and the proxy will emit the "destroy" signal
when the owner disappears from the message bus.
An example of the difference between dbus_g_proxy_new_for_name()
and dbus_g_proxy_new_for_name_owner(): if you provide the well-known name
"org.freedesktop.Database" dbus_g_proxy_new_for_name() remains bound
to that name as it changes owner. dbus_g_proxy_new_for_name_owner()
will fail if the name has no owner. If the name has an owner,
dbus_g_proxy_new_for_name_owner() will bind to the unique name
of that owner rather than the generic name.
DBusGProxy * dbus_g_proxy_new_from_proxy (DBusGProxy *proxy,const char *iface,const char *path);
dbus_g_proxy_new_from_proxy is deprecated and should not be used in newly-written code.
New code should use GDBus instead. The closest equivalent
is g_dbus_proxy_new_sync().
Creates a proxy using an existing proxy as a template, substituting the specified interface and path. Either or both may be NULL.
DBusGProxy * dbus_g_proxy_new_for_peer (DBusGConnection *connection,const char *path,const char *iface);
dbus_g_proxy_new_for_peer is deprecated and should not be used in newly-written code.
New code should use GDBus instead. The closest equivalent
is g_dbus_proxy_new_sync().
Creates a proxy for an object in peer application (one we're directly connected to). That is, this function is intended for use when there's no message bus involved, we're doing a simple 1-to-1 communication between two applications.
void dbus_g_proxy_set_interface (DBusGProxy *proxy,const char *interface_name);
dbus_g_proxy_set_interface is deprecated and should not be used in newly-written code.
New code should use GDBus instead. There is no direct equivalent for this function: construct a new proxy instead.
Sets the object interface proxy is bound to
It is an error to call this method on a proxy that has emitted the “destroy” signal.
const char *
dbus_g_proxy_get_path (DBusGProxy *proxy);
dbus_g_proxy_get_path is deprecated and should not be used in newly-written code.
New code should use GDBus instead. The closest equivalent
is g_dbus_proxy_get_object_path().
Gets the path this proxy is bound to
It is an error to call this method on a proxy that has emitted the “destroy” signal.
const char *
dbus_g_proxy_get_bus_name (DBusGProxy *proxy);
dbus_g_proxy_get_bus_name is deprecated and should not be used in newly-written code.
New code should use GDBus instead. The closest equivalent
is g_dbus_proxy_get_name() or g_dbus_proxy_get_name_owner(),
depending how the proxy was created.
Gets the bus name a proxy is bound to (may be NULL in some cases).
If you created the proxy with dbus_g_proxy_new_for_name(), then
the name you passed to that will be returned.
If you created it with dbus_g_proxy_new_for_name_owner(), then the
unique connection name will be returned. If you created it
with dbus_g_proxy_new_for_peer() then NULL will be returned.
It is an error to call this method on a proxy that has emitted the “destroy” signal.
const char *
dbus_g_proxy_get_interface (DBusGProxy *proxy);
dbus_g_proxy_get_interface is deprecated and should not be used in newly-written code.
New code should use GDBus instead. The closest equivalent
is g_dbus_proxy_get_interface_name().
Gets the object interface proxy is bound to (may be NULL in some cases).
It is an error to call this method on a proxy that has emitted the “destroy” signal.
void dbus_g_proxy_add_signal (DBusGProxy *proxy,const char *signal_name,GType first_type,...);
dbus_g_proxy_add_signal is deprecated and should not be used in newly-written code.
New code should use GDBus instead.
Specifies the argument signature of a D-Bus signal. When the signal is emitted by the remote object, if the GTypes corresponding to its arguments' types do not match the types given here, the signal will be ignored.
It is an error to add the same signal_name
to the same proxy
more than
once, even if the argument types given are the same.
It is also an error to call this method on a proxy that has emitted the “destroy” signal.
proxy |
the proxy for a remote interface |
|
signal_name |
the name of the signal |
|
first_type |
the first argument type, or |
|
... |
any subsequent argument types, followed by |
void dbus_g_proxy_connect_signal (DBusGProxy *proxy,const char *signal_name,GCallback handler,void *data,GClosureNotify free_data_func);
dbus_g_proxy_connect_signal is deprecated and should not be used in newly-written code.
New code should use GDBus instead. The closest equivalent
is g_dbus_connection_signal_subscribe().
Connect a signal handler to a proxy for a remote interface. When the remote interface emits the specified signal, the proxy will emit a corresponding GLib signal.
It is an error to call this method on a proxy that has emitted the “destroy” signal.
void dbus_g_proxy_disconnect_signal (DBusGProxy *proxy,const char *signal_name,GCallback handler,void *data);
dbus_g_proxy_disconnect_signal is deprecated and should not be used in newly-written code.
New code should use GDBus instead. The closest equivalent
is g_dbus_connection_signal_unsubscribe().
Disconnect all signal handlers from a proxy that match the given criteria.
It is an error to call this method on a proxy that has emitted the “destroy” signal.
void dbus_g_proxy_send (DBusGProxy *proxy,DBusMessage *message,dbus_uint32_t *client_serial);
dbus_g_proxy_send is deprecated and should not be used in newly-written code.
New code should use GDBus instead. The closest equivalent
is g_dbus_connection_send_message().
Sends a message to the interface we're proxying for. Does not
block or wait for a reply. The message is only actually written out
when you return to the main loop or block in
dbus_g_connection_flush().
The message is modified to be addressed to the target interface.
That is, a destination name field or whatever is needed will be
added to the message. The basic point of this function is to add
the necessary header fields, otherwise it's equivalent to
dbus_connection_send().
This function adds a reference to the message, so the caller still owns its original reference.
It is an error to call this method on a proxy that has emitted the “destroy” signal.
proxy |
a proxy for a remote interface |
|
message |
the message to address and send |
|
client_serial |
return location for message's serial, or |
gboolean dbus_g_proxy_call (DBusGProxy *proxy,const char *method,GError **error,GType first_arg_type,...);
dbus_g_proxy_call is deprecated and should not be used in newly-written code.
New code should use GDBus instead. The closest equivalent
is g_dbus_proxy_call_sync().
Function for synchronously invoking a method and receiving reply values. This function is equivalent to dbus_g_proxy_begin_call followed by dbus_g_proxy_end_call. All of the input arguments are specified first, followed by G_TYPE_INVALID, followed by all of the output values, followed by a second G_TYPE_INVALID. Note that this means you must always specify G_TYPE_INVALID twice.
It is an error to call this method on a proxy that has emitted the “destroy” signal.
proxy |
a proxy for a remote interface |
|
method |
method to invoke |
|
error |
return location for an error |
|
first_arg_type |
type of first "in" argument, or |
|
... |
value of first "in" argument, any further type/value pairs,
|
gboolean dbus_g_proxy_call_with_timeout (DBusGProxy *proxy,const char *method,int timeout,GError **error,GType first_arg_type,...);
dbus_g_proxy_call_with_timeout is deprecated and should not be used in newly-written code.
New code should use GDBus instead. The closest equivalent
is g_dbus_proxy_call_sync().
Function for synchronously invoking a method and receiving reply values. This function is equivalent to dbus_g_proxy_begin_call followed by dbus_g_proxy_end_call. All of the input arguments are specified first, followed by G_TYPE_INVALID, followed by all of the output values, followed by a second G_TYPE_INVALID. Note that this means you must always specify G_TYPE_INVALID twice.
It is an error to call this method on a proxy that has emitted the “destroy” signal.
proxy |
a proxy for a remote interface |
|
method |
method to invoke |
|
timeout |
the timeout in milliseconds, or -1 to use a default |
|
error |
return location for an error |
|
first_arg_type |
type of first "in" argument |
|
... |
as for |
void dbus_g_proxy_call_no_reply (DBusGProxy *proxy,const char *method,GType first_arg_type,...);
dbus_g_proxy_call_no_reply is deprecated and should not be used in newly-written code.
New code should use GDBus instead. The closest equivalent
is g_dbus_proxy_call() with callback
= NULL.
Sends a method call message as with dbus_g_proxy_begin_call(), but
does not ask for a reply or allow you to receive one.
It is an error to call this method on a proxy that has emitted the “destroy” signal.
TODO: this particular function shouldn't die on out of memory, since you should be able to do a call with large arguments.
proxy |
a proxy for a remote interface |
|
method |
the name of the method to invoke |
|
first_arg_type |
type of the first argument, or |
|
... |
the first argument and any remaining type/argument pairs, followed by
|
DBusGProxyCall * dbus_g_proxy_begin_call (DBusGProxy *proxy,const char *method,DBusGProxyCallNotify notify,gpointer user_data,GDestroyNotify destroy,GType first_arg_type,...);
dbus_g_proxy_begin_call is deprecated and should not be used in newly-written code.
New code should use GDBus instead. The closest equivalent
is g_dbus_proxy_call().
Asynchronously invokes a method on a remote interface. The method
call will not be sent over the wire until the application returns
to the main loop, or blocks in dbus_g_connection_flush() to write out
pending data. The call will be completed after a timeout, or when
a reply is received. When the call returns, the callback specified
will be invoked; you can then collect the results of the call
(which may be an error, or a reply), use dbus_g_proxy_end_call().
It is an error to call this method on a proxy that has emitted the “destroy” signal.
TODO this particular function shouldn't die on out of memory, since you should be able to do a call with large arguments.
proxy |
a proxy for a remote interface |
|
method |
the name of the method to invoke |
|
notify |
callback to be invoked when method returns |
|
user_data |
user data passed to callback |
|
destroy |
function called to destroy user_data |
|
first_arg_type |
type of the first argument, or |
|
... |
first argument, followed by any further type/value pairs, followed
by |
DBusGProxyCall * dbus_g_proxy_begin_call_with_timeout (DBusGProxy *proxy,const char *method,DBusGProxyCallNotify notify,gpointer user_data,GDestroyNotify destroy,int timeout,GType first_arg_type,...);
dbus_g_proxy_begin_call_with_timeout is deprecated and should not be used in newly-written code.
New code should use GDBus instead. The closest equivalent
is g_dbus_proxy_call().
Asynchronously invokes a method on a remote interface. The method
call will not be sent over the wire until the application returns
to the main loop, or blocks in dbus_g_connection_flush() to write out
pending data. The call will be completed after a timeout, or when
a reply is received. When the call returns, the callback specified
will be invoked; you can then collect the results of the call
(which may be an error, or a reply), use dbus_g_proxy_end_call().
It is an error to call this method on a proxy that has emitted the “destroy” signal.
TODO this particular function shouldn't die on out of memory, since you should be able to do a call with large arguments.
proxy |
a proxy for a remote interface |
|
method |
the name of the method to invoke |
|
notify |
callback to be invoked when method returns |
|
user_data |
user data passed to callback |
|
destroy |
function called to destroy user_data |
|
timeout |
the timeout in milliseconds, or -1 to use a default |
|
first_arg_type |
type of the first argument, or |
|
... |
first argument, followed by any further type/value pairs, followed
by |
gboolean dbus_g_proxy_end_call (DBusGProxy *proxy,DBusGProxyCall *call,GError **error,GType first_arg_type,...);
dbus_g_proxy_end_call is deprecated and should not be used in newly-written code.
New code should use GDBus instead. The closest equivalent
is g_dbus_proxy_call_finish().
Collects the results of a method call. The method call was normally
initiated with dbus_g_proxy_end_call(). You may use this function
outside of the callback given to dbus_g_proxy_begin_call; in that
case this function will block if the results haven't yet been
received.
All D-Bus method calls can fail with a remote error. If this occurs,
the error
will be set and this function will return FALSE.
Otherwise, the "out" parameters and return value of the method are stored in the provided varargs list. The list should be terminated with G_TYPE_INVALID.
proxy |
a proxy for a remote interface |
|
call |
the pending call ID from |
|
error |
return location for an error |
|
first_arg_type |
type of first "out" argument, or |
|
... |
return location for first "out" argument, followed by any further
type/location pairs, followed by |
void dbus_g_proxy_cancel_call (DBusGProxy *proxy,DBusGProxyCall *call);
dbus_g_proxy_cancel_call is deprecated and should not be used in newly-written code.
New code should use GDBus instead. The closest equivalent
is g_cancellable_cancel().
Cancels a pending method call. The method call was normally
initiated with dbus_g_proxy_begin_call(). This function
may not be used on pending calls that have already been
ended with dbus_g_proxy_end_call.
It is an error to call this method on a proxy that has emitted the “destroy” signal.
proxy |
a proxy for a remote interface |
|
call |
the pending call ID from |
void dbus_g_proxy_set_default_timeout (DBusGProxy *proxy,int timeout);
dbus_g_proxy_set_default_timeout is deprecated and should not be used in newly-written code.
New code should use GDBus instead.
Sets the default timeout to use for a proxy. This timeout will be used in calls where the timeout is not specified, or is specified to be -1. If this timeout is also set to -1, libdbus will use a reasonable default value.
This is useful for long-running operations that takes longer than the default timeout (which is a on the order of magnitude of tens of seconds). For some applications, consider using a pattern where the method returns once the operation is underway (e.g. immediately) and emits a signal when the operation terminates (though beware of leaking information with/in the signal return value).
It is an error to call this method on a proxy that has emitted the “destroy” signal.
proxy |
a proxy for a remote interface |
|
timeout |
the timeout in milliseconds, or -1 to reset to the libdbus default |
Since: 0.75
struct DBusGProxy {
};
DBusGProxy is deprecated and should not be used in newly-written code.
New code should use GDBus instead. The closest equivalent is GDBusProxy.
A GObject representing a remote object in a D-Bus service.
typedef struct _DBusGProxyCall DBusGProxyCall;
DBusGProxyCall is deprecated and should not be used in newly-written code.
New code should use GDBus instead. There is no direct equivalent in GDBus, but the standard GCancellable mechanism is analogous.
An opaque pointer representing an asynchronous call in progress.
| Top | |
|
|
|
| gchar * | dbus_g_method_get_sender () |
| DBusMessage * | dbus_g_method_get_reply () |
| void | dbus_g_method_send_reply () |
| void | dbus_g_method_return () |
| void | dbus_g_method_return_error () |
gchar *
dbus_g_method_get_sender (DBusGMethodInvocation *context);
dbus_g_method_get_sender is deprecated and should not be used in newly-written code.
New code should use GDBus instead. The closest equivalent
is g_dbus_method_invocation_get_sender().
Get the sender of a message so we can send a "reply" later (i.e. send a message directly to a service which invoked the method at a later time).
DBusMessage *
dbus_g_method_get_reply (DBusGMethodInvocation *context);
dbus_g_method_get_reply is deprecated and should not be used in newly-written code.
New code should use GDBus instead. The closest equivalent
is g_dbus_method_invocation_return_value().
Get the reply message to append reply values Used as a sidedoor when you can't generate dbus values of the correct type due to glib binding limitations
void dbus_g_method_send_reply (DBusGMethodInvocation *context,DBusMessage *reply);
dbus_g_method_send_reply is deprecated and should not be used in newly-written code.
New code should use GDBus instead. The closest equivalent
is g_dbus_method_invocation_return_value().
Send a manually created reply message.
Used as a sidedoor when you can't generate dbus values of the correct type due to glib binding limitations
void dbus_g_method_return (DBusGMethodInvocation *context,...);
dbus_g_method_return is deprecated and should not be used in newly-written code.
New code should use GDBus instead. The closest equivalent
is g_dbus_method_invocation_return_value().
Send a return message for a given method invocation, with arguments. This function also frees the sending context.
context |
the method context |
|
... |
zero or more values to return from the method, with their number and types given by its DBusGObjectInfo |
void dbus_g_method_return_error (DBusGMethodInvocation *context,const GError *error);
dbus_g_method_return_error is deprecated and should not be used in newly-written code.
New code should use GDBus instead. The closest equivalent
is g_dbus_method_invocation_return_gerror().
Send a error message for a given method invocation. This function also frees the sending context.
struct DBusGMethodInfo {
GCallback function;
GClosureMarshal marshaller;
int data_offset;
};
Object typically generated by dbus-binding-tool that stores a mapping from introspection data to a function pointer for a C method to be invoked.
GCallback |
C method to invoke |
|
GClosureMarshal |
Marshaller to invoke method |
|
Offset into the introspection data |
typedef struct _DBusGMethodInvocation DBusGMethodInvocation;
DBusGMethodInvocation is deprecated and should not be used in newly-written code.
New code should use GDBus instead. The closest equivalent is GDBusMethodInvocation.
The context of an asynchronous method call. See dbus_g_method_return() and
dbus_g_method_return_error().
| Top | |
|
|
|
| DBusGMessage * | dbus_g_message_ref () |
| void | dbus_g_message_unref () |
| DBusMessage * | dbus_g_message_get_message () |
DBusGMessage *
dbus_g_message_ref (DBusGMessage *message);
dbus_g_message_ref is deprecated and should not be used in newly-written code.
New code should use GDBusMessage instead.
Increment refcount on a DBusGMessage
void
dbus_g_message_unref (DBusGMessage *message);
dbus_g_message_unref is deprecated and should not be used in newly-written code.
New code should use GDBusMessage instead.
Decrement refcount on a DBusGMessage
DBusMessage *
dbus_g_message_get_message (DBusGMessage *gmessage);
dbus_g_message_get_message is deprecated and should not be used in newly-written code.
New code should use GDBus instead.
Get the DBusMessage corresponding to this DBusGMessage. The return value does not have its refcount incremented.
typedef struct _DBusGMessage DBusGMessage;
DBusGMessage is deprecated and should not be used in newly-written code.
New code should use GDBusMessage instead.
A DBusGMessage is a boxed type abstracting a DBusMessage from libdbus.
#define DBUS_TYPE_G_MESSAGE (dbus_g_message_get_g_type ())
DBUS_TYPE_G_MESSAGE is deprecated and should not be used in newly-written code.
New code should use GDBus instead.
Expands to a function call returning the boxed GType of a DBusGConnection.
| Top | |
|
|
|
| gboolean | dbus_g_error_has_name () |
| const char * | dbus_g_error_get_name () |
| void | dbus_g_error_domain_register () |
gboolean dbus_g_error_has_name (GError *error,const char *name);
dbus_g_error_has_name is deprecated and should not be used in newly-written code.
New code should use GDBus instead. The closest equivalent
is g_dbus_error_get_remote_error().
Determine whether D-BUS error name for a remote exception matches
the given name. This function is intended to be invoked on a
GError returned from an invocation of a remote method, e.g. via
dbus_g_proxy_end_call(). It will silently return FALSE for errors
which are not remote D-BUS exceptions (i.e. with a domain other
than DBUS_GERROR or a code other than
DBUS_GERROR_REMOTE_EXCEPTION).
const char *
dbus_g_error_get_name (GError *error);
dbus_g_error_get_name is deprecated and should not be used in newly-written code.
New code should use GDBus instead. The closest equivalent
is g_dbus_error_get_remote_error().
This function may only be invoked on a GError returned from an
invocation of a remote method, e.g. via dbus_g_proxy_end_call().
Moreover, you must ensure that the error's domain is DBUS_GERROR,
and the code is DBUS_GERROR_REMOTE_EXCEPTION.
void dbus_g_error_domain_register (GQuark domain,const char *default_iface,GType code_enum);
dbus_g_error_domain_register is deprecated and should not be used in newly-written code.
New code should use GDBus instead. The closest equivalent
is g_dbus_error_register_error_domain().
Register a GError domain and set of codes with D-Bus. When an object
raises a GError in the domain domain
from one of its D-Bus methods,
the D-Bus error name used will be default_iface
, followed by a dot,
followed by the GEnumValue.value_nick corresponding to the GError.code.
For D-Bus, it's conventional to use an error name (value_nick) that is
in CamelCase.
(For instance, if a D-Bus method com.example.MyObject.GetThings
can raise a GError with domain MY_ERROR and code
MY_ERROR_NOT_HAPPY, you could call
dbus_g_error_domain_register (MY_ERROR, "com.example.MyError",
MY_TYPE_ERROR), and set up the value_nick for
MY_ERROR_NOT_HAPPY to be NotHappy,
resulting in the D-Bus error string
com.example.MyError.NotHappy.)
If default_iface
is NULL, the D-Bus interface of the method that failed
will be used.
(For instance, if the above example had called
dbus_g_error_domain_register (MY_ERROR, NULL, MY_TYPE_ERROR)instead, then the D-Bus error string would be
com.example.MyObject.NotHappy.)
DBusGError is deprecated and should not be used in newly-written code.
New code should use GDBus and its GDBusError enum instead.
A GError enumeration for the domain DBUS_GERROR. The values' meanings
can be found by looking at the comments for the corresponding constants
in dbus-protocol.h.
#define DBUS_GERROR dbus_g_error_quark ()
DBUS_GERROR is deprecated and should not be used in newly-written code.
New code should use GDBus and its GDBusError enum instead.
Expands to a function call returning the error domain quark for DBusGError, for use with GError.
| Top | |
|
|
|
| DBusGConnection * | dbus_g_bus_get () |
| DBusGConnection * | dbus_g_bus_get_private () |
| void | dbus_g_thread_init () |
| DBusGConnection * | dbus_g_connection_open () |
| DBusGConnection * | dbus_g_connection_ref () |
| void | dbus_g_connection_unref () |
| void | dbus_g_connection_flush () |
| DBusConnection * | dbus_g_connection_get_connection () |
| void | dbus_g_connection_register_g_object () |
| void | dbus_g_connection_unregister_g_object () |
| GObject * | dbus_g_connection_lookup_g_object () |
DBusGConnection * dbus_g_bus_get (DBusBusType type,GError **error);
dbus_g_bus_get is deprecated and should not be used in newly-written code.
New code should use GDBus instead. The closest equivalent
is g_bus_get_sync().
Returns a connection to the given bus. The connection is a global variable shared with other callers of this function.
(Internally, calls dbus_bus_get() then calls
dbus_connection_setup_with_g_main() on the result.)
DBusGConnection * dbus_g_bus_get_private (DBusBusType type,GMainContext *context,GError **error);
dbus_g_bus_get_private is deprecated and should not be used in newly-written code.
New code should use GDBus instead. The closest equivalent
is g_bus_get_sync().
Returns a connection to the given bus. The connection will be a private non-shared connection and should be closed when usage is complete.
Internally this function calls dbus_bus_get_private() then calls
dbus_connection_setup_with_g_main() on the result; see the documentation
of the former function for more information on private connections.
void
dbus_g_thread_init (void);
dbus_g_thread_init is deprecated and should not be used in newly-written code.
New code should use GDBus instead. GDBus is always thread-safe, whereas dbus-glib is never thread-safe.
Initializes the D-BUS thread system. This function may only be called once and must be called prior to calling any other function in the D-BUS API.
Equivalent to dbus_threads_init_default(), which does nothing.
dbus-glib requires dbus >= 1.8, which is thread-safe by default.
Note that dbus-glib's GObject mapping is explicitly *not* thread-safe.
DBusGConnection * dbus_g_connection_open (const gchar *address,GError **error);
dbus_g_connection_open is deprecated and should not be used in newly-written code.
New code should use GDBus instead. The closest equivalent
is g_dbus_connection_new_for_address_sync().
Returns a connection to the given address.
(Internally, calls dbus_connection_open() then calls
dbus_connection_setup_with_g_main() on the result.)
DBusGConnection *
dbus_g_connection_ref (DBusGConnection *connection);
dbus_g_connection_ref is deprecated and should not be used in newly-written code.
New code should use GDBusConnection instead.
Increment refcount on a DBusGConnection
void
dbus_g_connection_unref (DBusGConnection *connection);
dbus_g_connection_unref is deprecated and should not be used in newly-written code.
New code should use GDBusConnection instead.
Decrement refcount on a DBusGConnection
void
dbus_g_connection_flush (DBusGConnection *connection);
dbus_g_connection_flush is deprecated and should not be used in newly-written code.
The closest equivalent in GDBus is
g_dbus_connection_flush_sync()
Blocks until outgoing calls and signal emissions have been sent.
DBusConnection *
dbus_g_connection_get_connection (DBusGConnection *gconnection);
dbus_g_connection_get_connection is deprecated and should not be used in newly-written code.
New code should use GDBus instead.
Get the DBusConnection corresponding to this DBusGConnection. The return value does not have its refcount incremented.
void dbus_g_connection_register_g_object (DBusGConnection *connection,const char *at_path,GObject *object);
dbus_g_connection_register_g_object is deprecated and should not be used in newly-written code.
New code should use GDBus instead.
The closest equivalent is g_dbus_connection_register_object(),
but GDBusObjectManagerServer and GDBusObjectSkeleton provide
a higher-level API.
Registers a GObject at the given path. Properties, methods, and signals
of the object can then be accessed remotely. Methods are only available
if method introspection data has been added to the object's class
with dbus_g_object_type_install_info().
The registration will be cancelled if either the DBusConnection or
the GObject gets finalized, or if dbus_g_connection_unregister_g_object()
is used.
Note: If an object is registered multiple times, the first registration takes priority for cases such as turning an object into an object path.
void dbus_g_connection_unregister_g_object (DBusGConnection *connection,GObject *object);
dbus_g_connection_unregister_g_object is deprecated and should not be used in newly-written code.
New code should use GDBus instead.
The closest equivalent is g_dbus_connection_unregister_object().
Removes object
from any object paths at which it is exported on
connection
. Properties, methods, and signals
of the object can no longer be accessed remotely.
GObject * dbus_g_connection_lookup_g_object (DBusGConnection *connection,const char *at_path);
dbus_g_connection_lookup_g_object is deprecated and should not be used in newly-written code.
New code should use GDBus instead. There is no direct equivalent for this function.
FIXME
typedef struct _DBusGConnection DBusGConnection;
DBusGConnection is deprecated and should not be used in newly-written code.
New code should use GDBusConnection from the GIO library, which is not based on libdbus or dbus-glib.
A DBusGConnection is a boxed type abstracting a DBusConnection from libdbus.
#define DBUS_TYPE_G_CONNECTION (dbus_g_connection_get_g_type ())
DBUS_TYPE_G_CONNECTION is deprecated and should not be used in newly-written code.
New code should use GDBus instead.
Expands to a function call returning the boxed GType of a DBusGConnection.
| Top | |
|
|
|
void dbus_g_object_type_install_info (GType object_type,const DBusGObjectInfo *info);
dbus_g_object_type_install_info is deprecated and should not be used in newly-written code.
New code should use GDBus instead. There is no direct equivalent for this function.
Install introspection information about the given object GType
sufficient to allow methods on the object to be invoked by name.
The introspection information is normally generated by
dbus-glib-tool, then this function is called in the
class_init() for the object class.
Once introspection information has been installed, instances of the
object registered with dbus_g_connection_register_g_object() can have
their methods invoked remotely.
void dbus_g_object_type_register_shadow_property (GType iface_type,const char *dbus_prop_name,const char *shadow_prop_name);
dbus_g_object_type_register_shadow_property is deprecated and should not be used in newly-written code.
New code should use GDBus instead. There is no equivalent for this function, because GDBus does not conflate GObject and D-Bus property names in the same way.
Registers a new property name shadow_prop_name
that overrides the
dbus_prop_name
in D-Bus property get/set requests. Since all properties for
all interfaces implemented by a GObject exist in the same namespace, this
allows implementations to use the same property name in two or more D-Bus
interfaces implemented by the same GObject, as long as one of those D-Bus
interface properties is registered with a shadow property name.
For example, if both org.foobar.Baz.InterfaceA and org.foobar.Baz.InterfaceB
have a D-Bus property called "Bork", the developer assigns a shadow property
name to the conflicting property name in one or both of these GInterfaces to
resolve the conflict. Assume the GInterface implementing
org.foobar.Baz.InterfaceA registers a shadow property called "a-bork", while
the GInterface implementing org.foobar.Baz.InterfaceB registers a shadow
property called "b-bork". The GObject implementing both these GInterfaces
would then use g_object_class_override_property()
iface_type |
GType for the GInterface |
|
dbus_prop_name |
D-Bus property name (as specified in the introspection data) to override with the shadow property name (as specified in the GType's initialization function, ie glib-style) |
|
shadow_prop_name |
property name which should override the shadow property |
void dbus_g_object_register_marshaller (GClosureMarshal marshaller,GType rettype,...);
dbus_g_object_register_marshaller is deprecated and should not be used in newly-written code.
New code should use GDBus instead.
Register a GClosureMarshal to be used for signal invocations,
giving its return type and a list of parameter types,
followed by G_TYPE_INVALID.
This function is no longer useful, and is only provided for compatibility with older dbus-glib. The GClosureMarshal will not be called.
marshaller |
a GClosureMarshal to be used for invocation |
|
rettype |
a GType for the return type of the function |
|
... |
The parameter GTypes, followed by |
void dbus_g_object_register_marshaller_array (GClosureMarshal marshaller,GType rettype,guint n_types,const GType *types);
dbus_g_object_register_marshaller_array is deprecated and should not be used in newly-written code.
New code should use GDBus instead.
Register a GClosureMarshal to be used for signal invocations.
see_also
dbus_g_object_register_marshaller()
marshaller |
a GClosureMarshal to be used for invocation |
|
rettype |
a GType for the return type of the function |
|
n_types |
number of function parameters |
|
types |
a C array of GTypes values |
void
dbus_glib_global_set_disable_legacy_property_access
(void);
dbus_glib_global_set_disable_legacy_property_access is deprecated and should not be used in newly-written code.
New code should use GDBus instead. There is no equivalent for this function.
For historical reasons, DBus-GLib will allow read-only
access to every GObject property of an object exported
to the bus, regardless of whether or not the property
is listed in the type info installed with
dbus_g_object_type_install_info(). (Write access is
denied however).
If you wish to restrict even read-only access, you can call this method to globally change the behavior for the entire process.
Since: 0.88
struct DBusGObjectInfo {
int format_version;
const DBusGMethodInfo *method_infos;
int n_method_infos;
const char *data;
const char *exported_signals;
const char *exported_properties;
};
Introspection data for a GObject, normally autogenerated by a tool such as dbus-binding-tool.
Allows us to change the rest of this struct by adding DBusGObjectInfo2, DBusGObjectInfo3, etc. |
||
const DBusGMethodInfo * |
Array of method pointers |
|
Length of the infos array |
||
Introspection data |
||
Exported signals |
||
Exported properties |
| Top | |
|
|
|
| void | dbus_set_g_error () |
| void | dbus_connection_setup_with_g_main () |
| DBusGConnection * | dbus_connection_get_g_connection () |
| void | dbus_server_setup_with_g_main () |
void dbus_set_g_error (GError **gerror,DBusError *derror);
dbus_set_g_error is deprecated and should not be used in newly-written code.
New code should use GDBus instead. GDBus' error encoding
is much simpler and more reliable, and the closest equivalent
is g_dbus_error_new_for_dbus_error().
Store the information from a DBus method error return into a GError. For the normal case of an arbitrary remote process, the error code will be DBUS_GERROR_REMOTE_EXCEPTION. Now, DBus errors have two components; a message and a "name". The former is an arbitrary (normally American English) string. The second is a string like com.example.FooFailure which programs can use as a conditional source. Because a GError only has one string, we use a hack to encode both values:
<human readable string><null><error name><null>
You can use the following code to retrieve both values:
1 2 |
size_t len = strlen(msg); const char *error_name = msg+len+1;]| |
void dbus_connection_setup_with_g_main (DBusConnection *connection,GMainContext *context);
dbus_connection_setup_with_g_main is deprecated and should not be used in newly-written code.
New code should use GDBus instead.
Modules that need to connect libdbus to a GLib main loop should
use the dbus-gmain submodule via git subtree or git submodule.
Sets the watch and timeout functions of a DBusConnection
to integrate the connection with the GLib main loop.
Pass in NULL for the GMainContext unless you're
doing something specialized.
If called twice for the same context, does nothing the second time. If called once with context A and once with context B, context B replaces context A as the context monitoring the connection.
DBusGConnection *
dbus_connection_get_g_connection (DBusConnection *connection);
dbus_connection_get_g_connection is deprecated and should not be used in newly-written code.
New code should use GDBus instead.
Get the DBusGConnection corresponding to this DBusConnection. This only makes sense if the DBusConnection was originally a DBusGConnection that was registered with the GLib main loop. The return value does not have its refcount incremented.
void dbus_server_setup_with_g_main (DBusServer *server,GMainContext *context);
dbus_server_setup_with_g_main is deprecated and should not be used in newly-written code.
New code should use GDBus instead.
Modules that need to connect libdbus to a GLib main loop should
use the dbus-gmain submodule via git subtree or git submodule.
Sets the watch and timeout functions of a DBusServer
to integrate the server with the GLib main loop.
In most cases the context argument should be NULL.
If called twice for the same context, does nothing the second time. If called once with context A and once with context B, context B replaces context A as the context monitoring the connection.
#define DBUS_TYPE_CONNECTION (dbus_connection_get_g_type ())
DBUS_TYPE_CONNECTION is deprecated and should not be used in newly-written code.
New code should use GDBus instead.
Expands to a function call returning a boxed GType representing a
DBusConnection pointer from libdbus. Not to be confused with
DBUS_TYPE_G_CONNECTION, which you should usually use instead.
#define DBUS_TYPE_MESSAGE (dbus_message_get_g_type ())
DBUS_TYPE_MESSAGE is deprecated and should not be used in newly-written code.
New code should use GDBus instead.
Expands to a function call returning a boxed GType representing a
DBusMessage pointer from libdbus. Not to be confused with
DBUS_TYPE_G_MESSAGE, which you should usually use instead.
|
|
|
|
dbus-binding-tooldbus-binding-tool — C language GLib bindings generation utility |
[options...] [files...]
|
 |
|
|
|
|
|
|
|
|
|
|
D-Bus is a message bus system, a simple way for applications to talk to one another. For more information on D-Bus, see http://www.freedesktop.org/wiki/Software/dbus.
dbus-glib is a deprecated API for use of D-Bus from GLib applications. Do not use it in new code.
Since version 2.26, GLib's accompanying GIO library provides a high-level API for D-Bus, "GDBus", based on an independent reimplementation of the D-Bus protocol. The maintainers of D-Bus recommend that GLib applications should use GDBus instead of dbus-glib.
|
|
|
 |
com.example.MyObject.GetThings
* can raise a #GError with domain MY_ERROR and code
* MY_ERROR_NOT_HAPPY, you could call
* dbus_g_error_domain_register (MY_ERROR, "com.example.MyError",
* MY_TYPE_ERROR), and set up the value_nick for
* MY_ERROR_NOT_HAPPY to be NotHappy,
* resulting in the D-Bus error string
* com.example.MyError.NotHappy.)
*
* If @default_iface is %NULL, the D-Bus interface of the method that failed
* will be used.
*
* (For instance, if the above example had called
* dbus_g_error_domain_register (MY_ERROR, NULL, MY_TYPE_ERROR)
* instead, then the D-Bus error string would be
* com.example.MyObject.NotHappy.)
*
* Deprecated: New code should use GDBus instead. The closest equivalent
* is g_dbus_error_register_error_domain().
*/
void
dbus_g_error_domain_register (GQuark domain,
const char *default_iface,
GType code_enum)
{
DBusGErrorInfo *info;
g_return_if_fail (g_quark_to_string (domain) != NULL);
g_return_if_fail (code_enum != G_TYPE_INVALID);
g_return_if_fail (G_TYPE_FUNDAMENTAL (code_enum) == G_TYPE_ENUM);
g_static_rw_lock_writer_lock (&globals_lock);
if (error_metadata == NULL)
g_datalist_init (&error_metadata);
info = g_datalist_id_get_data (&error_metadata, domain);
if (info != NULL)
{
g_warning ("Metadata for error domain \"%s\" already registered\n",
g_quark_to_string (domain));
}
else
{
info = g_new0 (DBusGErrorInfo, 1);
info->default_iface = g_strdup (default_iface);
info->code_enum = code_enum;
g_datalist_id_set_data_full (&error_metadata,
domain,
info,
dbus_g_error_info_free);
}
g_static_rw_lock_writer_unlock (&globals_lock);
}
/* Called when the object is destroyed */
static void
object_export_object_died (gpointer user_data, GObject *dead)
{
ObjectExport *oe = user_data;
g_assert (dead == oe->object);
/* this prevents the weak unref from taking place, which would cause an
* assertion failure since the object has already gone... */
oe->object = NULL;
/* ... while this results in a call to object_registration_unregistered
* for each contained registration */
object_export_unregister_all (oe);
/* We deliberately don't remove the ObjectExport yet, in case the object is
* resurrected and re-registered: if that happens, we wouldn't want to call
* export_signals() again. */
}
/**
* dbus_g_connection_unregister_g_object:
* @connection: the D-BUS connection
* @object: the object
*
* Removes @object from any object paths at which it is exported on
* @connection. Properties, methods, and signals
* of the object can no longer be accessed remotely.
*
* Deprecated: New code should use GDBus instead.
* The closest equivalent is g_dbus_connection_unregister_object().
*/
void
dbus_g_connection_unregister_g_object (DBusGConnection *connection,
GObject *object)
{
ObjectExport *oe;
GSList *registrations;
g_return_if_fail (connection != NULL);
g_return_if_fail (G_IS_OBJECT (object));
oe = g_object_get_data (object, "dbus_glib_object_registrations");
g_return_if_fail (oe != NULL);
g_return_if_fail (oe->registrations != NULL);
/* Copy the list before iterating it: it will be modified in
* object_registration_free() each time an object path is unregistered.
*/
for (registrations = g_slist_copy (oe->registrations);
registrations != NULL;
registrations = g_slist_delete_link (registrations, registrations))
{
ObjectRegistration *o = registrations->data;
if (o->connection != connection)
continue;
dbus_connection_unregister_object_path (DBUS_CONNECTION_FROM_G_CONNECTION (o->connection),
o->object_path);
}
}
/**
* dbus_g_connection_register_g_object:
* @connection: the D-BUS connection
* @at_path: the path where the object will live (the object's name)
* @object: the object
*
* Registers a #GObject at the given path. Properties, methods, and signals
* of the object can then be accessed remotely. Methods are only available
* if method introspection data has been added to the object's class
* with dbus_g_object_type_install_info().
*
* The registration will be cancelled if either the #DBusConnection or
* the #GObject gets finalized, or if dbus_g_connection_unregister_g_object()
* is used.
*
* Note: If an object is registered multiple times, the first registration
* takes priority for cases such as turning an object into an object path.
*
* Deprecated: New code should use GDBus instead.
* The closest equivalent is g_dbus_connection_register_object(),
* but #GDBusObjectManagerServer and #GDBusObjectSkeleton provide
* a higher-level API.
*/
void
dbus_g_connection_register_g_object (DBusGConnection *connection,
const char *at_path,
GObject *object)
{
ObjectExport *oe;
GSList *iter;
ObjectRegistration *o;
DBusError error;
g_return_if_fail (connection != NULL);
g_return_if_fail (g_variant_is_object_path (at_path));
g_return_if_fail (G_IS_OBJECT (object));
oe = g_object_get_data (object, "dbus_glib_object_registrations");
if (oe == NULL)
{
GList *info_list = lookup_object_info (object);
if (info_list == NULL)
{
g_warning ("No introspection data registered for object class \"%s\"",
g_type_name (G_TYPE_FROM_INSTANCE (object)));
return;
}
/* This adds a hook into every signal for the object. Only do this
* on the first registration, because inside the signal marshaller
* we emit a signal for each registration.
*/
export_signals (info_list, object);
g_list_free (info_list);
oe = object_export_new ();
g_object_set_data_full (object, "dbus_glib_object_registrations", oe,
(GDestroyNotify) object_export_free);
}
if (oe->object == NULL)
{
/* Either the ObjectExport is newly-created, or it already existed but
* the object was disposed and resurrected, causing the weak ref to
* fall off */
oe->object = object;
g_object_weak_ref (object, object_export_object_died, oe);
}
for (iter = oe->registrations; iter; iter = iter->next)
{
o = iter->data;
/* Silently ignore duplicate registrations */
if (strcmp (o->object_path, at_path) == 0 && o->connection == connection)
return;
}
o = object_registration_new (connection, at_path, oe);
dbus_error_init (&error);
if (!dbus_connection_try_register_object_path (DBUS_CONNECTION_FROM_G_CONNECTION (connection),
at_path,
&gobject_dbus_vtable,
o,
&error))
{
g_error ("Failed to register GObject with DBusConnection: %s %s",
error.name, error.message);
dbus_error_free (&error);
object_registration_free (o);
return;
}
oe->registrations = g_slist_append (oe->registrations, o);
}
/**
* dbus_g_connection_lookup_g_object:
* @connection: a #DBusGConnection
* @at_path: path
*
* FIXME
*
* Returns: the object at path @at_path
*
* Deprecated: New code should use GDBus instead. There is no direct
* equivalent for this function.
*/
GObject *
dbus_g_connection_lookup_g_object (DBusGConnection *connection,
const char *at_path)
{
gpointer p;
ObjectRegistration *o;
g_return_val_if_fail (connection != NULL, NULL);
g_return_val_if_fail (g_variant_is_object_path (at_path), NULL);
if (!dbus_connection_get_object_path_data (DBUS_CONNECTION_FROM_G_CONNECTION (connection), at_path, &p))
return NULL;
if (p == NULL)
return NULL;
o = p;
if (o->export->object == NULL)
return NULL;
return G_OBJECT (o->export->object);
}
typedef struct {
GType rettype;
guint n_params;
GType *params;
} DBusGFuncSignature;
/**
* dbus_g_object_register_marshaller:
* @marshaller: a GClosureMarshal to be used for invocation
* @rettype: a GType for the return type of the function
* @...: The parameter #GTypes, followed by %G_TYPE_INVALID
*
* Register a #GClosureMarshal to be used for signal invocations,
* giving its return type and a list of parameter types,
* followed by %G_TYPE_INVALID.
*
* This function is no longer useful, and is only provided
* for compatibility with older dbus-glib. The #GClosureMarshal
* will not be called.
*
* Deprecated: New code should use GDBus instead.
*/
void
dbus_g_object_register_marshaller (GClosureMarshal marshaller,
GType rettype,
...)
{
}
/**
* dbus_g_object_register_marshaller_array:
* @marshaller: a #GClosureMarshal to be used for invocation
* @rettype: a #GType for the return type of the function
* @n_types: number of function parameters
* @types: a C array of GTypes values
*
* Register a #GClosureMarshal to be used for signal invocations.
* @see_also dbus_g_object_register_marshaller()
*
* Deprecated: New code should use GDBus instead.
*/
void
dbus_g_object_register_marshaller_array (GClosureMarshal marshaller,
GType rettype,
guint n_types,
const GType* types)
{
}
/**
* dbus_g_method_get_sender:
* @context: the method context
*
* Get the sender of a message so we can send a
* "reply" later (i.e. send a message directly
* to a service which invoked the method at a
* later time).
*
* Returns: the unique name of the sender. It
* is up to the caller to free the returned string.
*
* Deprecated: New code should use GDBus instead. The closest equivalent
* is g_dbus_method_invocation_get_sender().
*/
gchar *
dbus_g_method_get_sender (DBusGMethodInvocation *context)
{
const gchar *sender;
g_return_val_if_fail (context != NULL, NULL);
sender = dbus_message_get_sender (dbus_g_message_get_message (context->message));
return g_strdup (sender);
}
/**
* dbus_g_method_get_reply:
* @context: the method context
*
* Get the reply message to append reply values
* Used as a sidedoor when you can't generate dbus values
* of the correct type due to glib binding limitations
*
* Returns: a #DBusMessage with the reply
*
* Deprecated: New code should use GDBus instead. The closest equivalent
* is g_dbus_method_invocation_return_value().
*/
DBusMessage *
dbus_g_method_get_reply (DBusGMethodInvocation *context)
{
g_return_val_if_fail (context != NULL, NULL);
return reply_or_die (dbus_g_message_get_message (context->message));
}
/**
* dbus_g_method_send_reply:
* @context: the method context
* @reply: the reply message, will be unreffed
*
* Send a manually created reply message.
*
* Used as a sidedoor when you can't generate dbus values
* of the correct type due to glib binding limitations
*
* Deprecated: New code should use GDBus instead. The closest equivalent
* is g_dbus_method_invocation_return_value().
*/
void
dbus_g_method_send_reply (DBusGMethodInvocation *context, DBusMessage *reply)
{
g_return_if_fail (context != NULL);
g_return_if_fail (reply != NULL);
connection_send_or_die (dbus_g_connection_get_connection (context->connection),
reply);
dbus_message_unref (reply);
dbus_g_connection_unref (context->connection);
dbus_g_message_unref (context->message);
g_free (context);
}
/**
* dbus_g_method_return:
* @context: the method context
* @...: zero or more values to return from the method, with their number
* and types given by its #DBusGObjectInfo
*
* Send a return message for a given method invocation, with arguments.
* This function also frees the sending context.
*
* Deprecated: New code should use GDBus instead. The closest equivalent
* is g_dbus_method_invocation_return_value().
*/
void
dbus_g_method_return (DBusGMethodInvocation *context, ...)
{
DBusMessage *reply;
DBusMessageIter iter;
va_list args;
char *out_sig;
GArray *argsig;
guint i;
g_return_if_fail (context != NULL);
/* This field was initialized inside invoke_object_method; we
* carry it over through the async invocation to here.
*/
if (!context->send_reply)
goto out;
reply = dbus_g_method_get_reply (context);
out_sig = method_output_signature_from_object_info (context->object, context->method);
argsig = _dbus_gtypes_from_arg_signature (out_sig, FALSE);
dbus_message_iter_init_append (reply, &iter);
va_start (args, context);
for (i = 0; i < argsig->len; i++)
{
GValue value = {0,};
char *error;
g_value_init (&value, g_array_index (argsig, GType, i));
error = NULL;
G_VALUE_COLLECT (&value, args, G_VALUE_NOCOPY_CONTENTS, &error);
if (error)
{
g_warning("%s", error);
g_free (error);
}
else
{
if (!_dbus_gvalue_marshal (&iter, &value))
g_warning ("failed to marshal parameter %d for method %s",
i, dbus_message_get_member (
dbus_g_message_get_message (context->message)));
}
}
va_end (args);
connection_send_or_die (dbus_g_connection_get_connection (context->connection),
reply);
dbus_message_unref (reply);
g_free (out_sig);
g_array_free (argsig, TRUE);
out:
dbus_g_connection_unref (context->connection);
dbus_g_message_unref (context->message);
g_free (context);
}
/**
* dbus_g_method_return_error:
* @context: the method context
* @error: the error to send
*
* Send a error message for a given method invocation.
* This function also frees the sending context.
*
* Deprecated: New code should use GDBus instead. The closest equivalent
* is g_dbus_method_invocation_return_gerror().
*/
void
dbus_g_method_return_error (DBusGMethodInvocation *context, const GError *error)
{
DBusMessage *reply;
g_return_if_fail (context != NULL);
g_return_if_fail (error != NULL);
/* See comment in dbus_g_method_return */
if (!context->send_reply)
goto out;
reply = gerror_to_dbus_error_message (context->object, dbus_g_message_get_message (context->message), error);
connection_send_or_die (
dbus_g_connection_get_connection (context->connection), reply);
dbus_message_unref (reply);
out:
dbus_g_connection_unref (context->connection);
dbus_g_message_unref (context->message);
g_free (context);
}
/**
* dbus_g_method_invocation_get_g_connection:
* @context: the method context
*
*
*
* Returns: (transfer none): the @DBusGConnection from which the method was called.
*
* Deprecated: New code should use GDBus instead. The closest equivalent
* is g_dbus_method_invocation_get_connection().
*/
DBusGConnection *
dbus_g_method_invocation_get_g_connection (DBusGMethodInvocation *context)
{
g_return_val_if_fail (context != NULL, NULL);
return context->connection;
}
const char *
_dbus_gobject_get_path (GObject *obj)
{
ObjectExport *oe;
ObjectRegistration *o;
oe = g_object_get_data (obj, "dbus_glib_object_registrations");
if (oe == NULL || oe->registrations == NULL)
return NULL;
/* First one to have been registered wins */
o = oe->registrations->data;
return o->object_path;
}
#ifdef DBUS_BUILD_TESTS
#include