dbus/glib dbus-gproxy.c, 1.34, 1.35 dbus-gparser.c, 1.16,
1.17 dbus-gobject.c, 1.38, 1.39 dbus-glib.c, 1.7,
1.8 dbus-binding-tool-glib.c, 1.14, 1.15
Colin Walters
walters at freedesktop.org
Wed Jul 6 14:27:51 PDT 2005
Update of /cvs/dbus/dbus/glib
In directory gabe:/tmp/cvs-serv26636/glib
Modified Files:
dbus-gproxy.c dbus-gparser.c dbus-gobject.c dbus-glib.c
dbus-binding-tool-glib.c
Log Message:
2005-07-06 Colin Walters <walters at verbum.org>
* dbus/dbus-glib.h (DBusGPendingCall, DBusGPendingCallNotify)
(DBUS_TYPE_G_PENDING_CALL, dbus_g_pending_call_get_g_type)
(dbus_g_pending_call_ref, dbus_g_pending_call_unref): Delete.
(dbus_g_pending_call_set_notify, dbus_g_pending_call_cancel):
Delete in favor of dbus_g_proxy_begin_call and
dbus_g_proxy_cancel_call.
(DBusGProxyCall, DBusGProxyCallNotify): New.
(dbus_g_proxy_begin_call): Change prototype to take callback, user
data, and destroy function. This replaces
dbus_g_pending_call_set_notify.
(dbus_g_proxy_cancel_call): Prototype.
(DBusGAsyncData): Delete, shouldn't be needed anymore.
* glib/dbus-gproxy.c (struct _DBusGProxy): Add call_id_counter and
pending_calls map.
(struct _DBusGProxyManager): Add bus_proxy member, which is an
internal proxy for calls to the bus. Remove
pending_nameowner_calls, now the internal proxy keeps track.
(dbus_g_proxy_manager_unref): Unref bus proxy, remove reference to
pending_nameowner_calls.
(got_name_owner_cb): Update prototype, and use
dbus_g_proxy_end_call.
(got_name_owner_cb): Remove reference to pending_nameowner_calls.
(dbus_g_proxy_manager_register): Delete directly libdbus code in
favor of using internal proxy.
(dbus_g_proxy_manager_unregister): Update to use
dbus_g_proxy_cancel_call for any pending GetNameOwner call.
(dbus_g_proxy_init): Initialize pending calls map.
(dbus_g_proxy_constructor): New.
(dbus_g_proxy_class_init): Add get/set property functions,
constructor, and add NAME, PATH, and INTERFACE properties.
(cancel_pending_call): New function.
(dbus_g_proxy_dispose): Iterate over any outstanding calls and
cancel them.
(dbus_g_proxy_set_property, dbus_g_proxy_get_property): New.
(GPendingNotifyClosure): New structure.
(d_pending_call_notify, d_pending_call_free): Moved here from
dbus-glib.c.
(DBUS_G_VALUE_ARRAY_COLLECT_ALL): Moved around to satisfy function
ordering.
(manager_begin_bus_call): New internal function for talking to
internal bus proxy.
(dbus_g_proxy_new): Construct object using GObjet properties.
(dbus_g_proxy_begin_call_internal): Update to take user data, etc.
Create closure of same, and insert call into map of pending calls.
(dbus_g_proxy_end_call_internal): Take call id instead of pending
call. Look up pending call in current set. Remove it when we've
completed.
(dbus_g_pending_call_end, dbus_g_proxy_end_call_internal): Delete.
(dbus_g_proxy_begin_call): Change API to take callback, user data,
and destroy function directly.
(dbus_g_proxy_end_call): Update to take DBusGProxyCall.
(dbus_g_proxy_call): Invoke with NULL callback.
(dbus_g_proxy_cancel_call): New function, replaces
dbus_g_pending_call_cancel.
* glib/dbus-gparser.c (validate_signature): Fix call to
dbus_set_g_error.
* glib/dbus-gobject.c (dbus_g_object_type_dbus_metadata_quark):
New quark for attaching metadata to GType.
(info_hash): Delete.
(lookup_object_info): Look up using quark.
(dbus_g_object_type_install_info): Check that a type is classed,
not that it's an object. Also just install type data using quark
instead of using global hash.
* glib/dbus-glib.c (dbus_g_pending_call_ref)
(dbus_g_pending_call_unref, dbus_pending_call_get_g_type)
(GPendingNotifyClosure): Delete.
(d_pending_call_notify, d_pending_call_free): Move to dbus-gproxy.c.
(dbus_g_pending_call_set_notify, dbus_g_pending_call_cancel): Delete.
* glib/dbus-binding-tool-glib.c (generate_client_glue): Disable async
client method generation until we can fix it...
* tools/dbus-viewer.c (load_child_nodes): Use dbus_g_proxy_call.
(load_from_service_thread_func): Ditto.
* tools/dbus-names-model.c (struct NamesModel): Hold
DBusGProxyCall.
(have_names_notify): Update prototype, use
dbus_g_proxy_cancel_call.
(names_model_reload): Update for new dbus_g_proxy_begin_call API.
* tools/dbus-monitor.c (filter_func): Update for print_message
API change.
* test/glib/test-dbus-glib.c: Add more tests for async
invocations. Update many begin_call/end_call pairs to just use
dbus_g_proxy_call.
* tools/dbus-send.c (main): Add --print-reply=literal mode. This
allows us to dump print-introspect.c.
* tools/dbus-print-message.h (print_message): Add literal argument
to print_message which is intended to allow printing arguments without
metadata like "string=".
* tools/dbus-print-message.c (print_iter): Add literal argument.
(print_message): Allow printing string messages literally.
Index: dbus-gproxy.c
===================================================================
RCS file: /cvs/dbus/dbus/glib/dbus-gproxy.c,v
retrieving revision 1.34
retrieving revision 1.35
diff -u -d -r1.34 -r1.35
--- dbus-gproxy.c 5 Jul 2005 16:39:56 -0000 1.34
+++ dbus-gproxy.c 6 Jul 2005 21:27:49 -0000 1.35
@@ -32,6 +32,9 @@
#include <glib/gi18n.h>
#include <gobject/gvaluecollector.h>
+#define DBUS_G_PROXY_CALL_TO_ID(x) (GPOINTER_TO_UINT(x))
+#define DBUS_G_PROXY_ID_TO_CALL(x) (GUINT_TO_POINTER(x))
+
/**
* @addtogroup DBusGLibInternals
*
@@ -56,11 +59,16 @@
char *path; /**< Path messages go to or NULL */
char *interface; /**< Interface messages go to or NULL */
- DBusGPendingCall *name_call;/**< Pending call to retrieve name owner */
+ DBusGProxyCall *name_call; /**< Pending call id to retrieve name owner */
guint for_owner : 1; /**< Whether or not this proxy is for a name owner */
guint associated : 1; /**< Whether or not this proxy is associated (for name proxies) */
+ /* FIXME: make threadsafe? */
+ guint call_id_counter; /**< Integer counter for pending calls */
+
GData *signal_signatures; /**< D-BUS signatures for each signal */
+
+ GHashTable *pending_calls; /**< Calls made on this proxy which have not yet returned */
};
/**
@@ -73,18 +81,42 @@
static void dbus_g_proxy_init (DBusGProxy *proxy);
static void dbus_g_proxy_class_init (DBusGProxyClass *klass);
+static GObject *dbus_g_proxy_constructor (GType type,
+ guint n_construct_properties,
+ GObjectConstructParam *construct_properties);
+static void dbus_g_proxy_set_property (GObject *object,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec);
+static void dbus_g_proxy_get_property (GObject *object,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec);
+
static void dbus_g_proxy_finalize (GObject *object);
static void dbus_g_proxy_dispose (GObject *object);
static void dbus_g_proxy_destroy (DBusGProxy *proxy);
static void dbus_g_proxy_emit_remote_signal (DBusGProxy *proxy,
DBusMessage *message);
-static gboolean dbus_g_pending_call_end (DBusGConnection *connection,
- DBusGProxy *proxycon,
- DBusGPendingCall *pending,
- GError **error,
- GType first_arg_type,
- ...);
+static DBusGProxyCall *manager_begin_bus_call (DBusGProxyManager *manager,
+ const char *method,
+ DBusGProxyCallNotify notify,
+ gpointer data,
+ GDestroyNotify destroy,
+ GType first_arg_type,
+ ...);
+static guint dbus_g_proxy_begin_call_internal (DBusGProxy *proxy,
+ const char *method,
+ DBusGProxyCallNotify notify,
+ gpointer data,
+ GDestroyNotify destroy,
+ GValueArray *args);
+static gboolean dbus_g_proxy_end_call_internal (DBusGProxy *proxy,
+ guint call_id,
+ GError **error,
+ GType first_arg_type,
+ va_list args);
/**
* A list of proxies with a given name+path+interface, used to
@@ -112,6 +144,8 @@
int refcount; /**< Reference count */
DBusConnection *connection; /**< Connection we're associated with. */
+ DBusGProxy *bus_proxy; /**< Special internal proxy used to talk to the bus */
+
GHashTable *proxy_lists; /**< Hash used to route incoming signals
* and iterate over proxies
*/
@@ -119,9 +153,6 @@
* base name -> [name,name,...] for proxies which
* are for names.
*/
- GSList *pending_nameowner_calls; /**< List to keep track of pending
- * GetNameOwner calls
- */
GSList *unassociated_proxies; /**< List of name proxies for which
* there was no result for
* GetNameOwner
@@ -168,7 +199,7 @@
manager->refcount = 1;
manager->connection = connection;
-
+
g_static_mutex_init (&manager->lock);
/* Proxy managers keep the connection alive, which means that
@@ -215,6 +246,9 @@
{
UNLOCK_MANAGER (manager);
+ if (manager->bus_proxy)
+ g_object_unref (manager->bus_proxy);
+
if (manager->proxy_lists)
{
/* can't have any proxies left since they hold
@@ -238,7 +272,6 @@
manager->owner_names = NULL;
}
- g_assert (manager->pending_nameowner_calls == NULL);
g_assert (manager->unassociated_proxies == NULL);
g_static_mutex_free (&manager->lock);
@@ -723,13 +756,13 @@
}
static void
-got_name_owner_cb (DBusGPendingCall *pending,
+got_name_owner_cb (DBusGProxy *bus_proxy,
+ DBusGProxyCall *call,
void *user_data)
{
DBusGProxy *proxy;
GError *error;
char *owner;
- GSList *link;
proxy = user_data;
error = NULL;
@@ -737,15 +770,9 @@
LOCK_MANAGER (proxy->manager);
- link = g_slist_find (proxy->manager->pending_nameowner_calls, pending);
- g_assert (link != NULL);
-
- if (!dbus_g_pending_call_end (DBUS_G_CONNECTION_FROM_CONNECTION (proxy->manager->connection),
- NULL,
- pending,
- &error,
- G_TYPE_STRING, &owner,
- G_TYPE_INVALID))
+ if (!dbus_g_proxy_end_call (bus_proxy, call, &error,
+ G_TYPE_STRING, &owner,
+ G_TYPE_INVALID))
{
if (error->domain == DBUS_GERROR && error->code == DBUS_GERROR_NAME_HAS_NO_OWNER)
{
@@ -767,7 +794,6 @@
out:
proxy->name_call = NULL;
- proxy->manager->pending_nameowner_calls = g_slist_delete_link (proxy->manager->pending_nameowner_calls, link);
UNLOCK_MANAGER (proxy->manager);
g_free (owner);
}
@@ -911,46 +937,14 @@
if (!dbus_g_proxy_manager_lookup_name_owner (manager, proxy->name, &info, &owner))
{
- DBusPendingCall *pending;
- DBusGPendingCall *gpending;
- DBusMessage *request, *reply;
-
- g_assert (owner == NULL);
-
- reply = NULL;
-
- request = dbus_message_new_method_call (DBUS_SERVICE_DBUS,
- DBUS_PATH_DBUS,
- DBUS_INTERFACE_DBUS,
- "GetNameOwner");
- if (request == NULL)
- g_error ("Out of memory");
-
- if (!dbus_message_append_args (request,
- DBUS_TYPE_STRING, &(proxy->name),
- DBUS_TYPE_INVALID))
- g_error ("Out of memory");
-
- if (!dbus_connection_send_with_reply (manager->connection,
- request,
- &pending,
- -1))
- g_error ("Out of memory");
- g_assert (pending != NULL);
-
- gpending = DBUS_G_PENDING_CALL_FROM_PENDING_CALL (pending);
-
- /* It's safe to keep a reference to proxy here;
- * when the proxy is unreffed we cancel the call
- */
- dbus_g_pending_call_set_notify (gpending,
- got_name_owner_cb,
- proxy,
- NULL);
+ proxy->name_call = manager_begin_bus_call (manager, "GetNameOwner",
+ got_name_owner_cb,
+ proxy, NULL,
+ G_TYPE_STRING,
+ proxy->name,
+ G_TYPE_INVALID);
proxy->associated = FALSE;
- proxy->name_call = gpending;
- manager->pending_nameowner_calls = g_slist_prepend (manager->pending_nameowner_calls, gpending);
}
else
{
@@ -1003,14 +997,10 @@
{
GSList *link;
- if (proxy->name_call != NULL)
+ if (proxy->name_call != 0)
{
- link = g_slist_find (manager->pending_nameowner_calls, proxy->name_call);
- g_assert (link != NULL);
-
- dbus_g_pending_call_cancel (proxy->name_call);
-
- manager->pending_nameowner_calls = g_slist_delete_link (manager->pending_nameowner_calls, link);
+ dbus_g_proxy_cancel_call (manager->bus_proxy, proxy->name_call);
+ proxy->name_call = 0;
}
else
{
@@ -1022,7 +1012,7 @@
}
else
{
- g_assert (proxy->name_call == NULL);
+ g_assert (proxy->name_call == 0);
dbus_g_proxy_manager_unmonitor_name_owner (manager, proxy->name);
}
@@ -1267,6 +1257,13 @@
const GValue *param_values,
gpointer invocation_hint,
gpointer marshal_data);
+enum
+{
+ PROP_0,
+ PROP_NAME,
+ PROP_PATH,
+ PROP_INTERFACE
+};
enum
{
@@ -1282,6 +1279,31 @@
dbus_g_proxy_init (DBusGProxy *proxy)
{
g_datalist_init (&proxy->signal_signatures);
+ proxy->pending_calls = g_hash_table_new_full (NULL, NULL, NULL,
+ (GDestroyNotify) dbus_pending_call_unref);
+}
+
+static GObject *
+dbus_g_proxy_constructor (GType type,
+ guint n_construct_properties,
+ GObjectConstructParam *construct_properties)
+{
+ DBusGProxy *proxy;
+ DBusGProxyClass *klass;
+ GObjectClass *parent_class;
+
+ klass = DBUS_G_PROXY_CLASS (g_type_class_peek (DBUS_TYPE_G_PROXY));
+
+ parent_class = G_OBJECT_CLASS (g_type_class_peek_parent (klass));
+
+ proxy = DBUS_G_PROXY (parent_class->constructor (type, n_construct_properties,
+ construct_properties));
+
+ proxy->for_owner = (proxy->name[0] == ':');
+ proxy->name_call = 0;
+ proxy->associated = FALSE;
+
+ return G_OBJECT (proxy);
}
static void
@@ -1290,9 +1312,37 @@
GObjectClass *object_class = G_OBJECT_CLASS (klass);
parent_class = g_type_class_peek_parent (klass);
+
+ object_class->set_property = dbus_g_proxy_set_property;
+ object_class->get_property = dbus_g_proxy_get_property;
+
+ g_object_class_install_property (object_class,
+ PROP_NAME,
+ g_param_spec_string ("name",
+ "name",
+ "name",
+ NULL,
+ G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
+
+ g_object_class_install_property (object_class,
+ PROP_PATH,
+ g_param_spec_string ("path",
+ "path",
+ "path",
+ NULL,
+ G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
+
+ g_object_class_install_property (object_class,
+ PROP_INTERFACE,
+ g_param_spec_string ("interface",
+ "interface",
+ "interface",
+ NULL,
+ G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
object_class->finalize = dbus_g_proxy_finalize;
object_class->dispose = dbus_g_proxy_dispose;
+ object_class->constructor = dbus_g_proxy_constructor;
signals[DESTROY] =
g_signal_new ("destroy",
@@ -1314,18 +1364,31 @@
}
static void
+cancel_pending_call (gpointer key, gpointer val, gpointer data)
+{
+ DBusGProxyCall *call = key;
+ DBusGProxy *proxy = data;
+
+ dbus_g_proxy_cancel_call (proxy, call);
+}
+
+static void
dbus_g_proxy_dispose (GObject *object)
{
DBusGProxy *proxy;
proxy = DBUS_G_PROXY (object);
- if (proxy->manager)
+ /* Cancel outgoing pending calls */
+ g_hash_table_foreach (proxy->pending_calls, cancel_pending_call, proxy);
+ g_hash_table_destroy (proxy->pending_calls);
+
+ if (proxy->manager && proxy != proxy->manager->bus_proxy)
{
dbus_g_proxy_manager_unregister (proxy->manager, proxy);
dbus_g_proxy_manager_unref (proxy->manager);
- proxy->manager = NULL;
}
+ proxy->manager = NULL;
g_datalist_clear (&proxy->signal_signatures);
@@ -1359,6 +1422,56 @@
g_object_run_dispose (G_OBJECT (proxy));
}
+static void
+dbus_g_proxy_set_property (GObject *object,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec)
+{
+ DBusGProxy *proxy = DBUS_G_PROXY (object);
+
+ switch (prop_id)
+ {
+ case PROP_NAME:
+ proxy->name = g_strdup (g_value_get_string (value));
+ break;
+ case PROP_PATH:
+ proxy->path = g_strdup (g_value_get_string (value));
+ break;
+ case PROP_INTERFACE:
+ proxy->interface = g_strdup (g_value_get_string (value));
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+}
+
+static void
+dbus_g_proxy_get_property (GObject *object,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec)
+{
+ DBusGProxy *proxy = DBUS_G_PROXY (object);
+
+ switch (prop_id)
+ {
+ case PROP_NAME:
+ g_value_set_string (value, proxy->name);
+ break;
+ case PROP_PATH:
+ g_value_set_string (value, proxy->path);
+ break;
+ case PROP_INTERFACE:
+ g_value_set_string (value, proxy->interface);
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+}
+
/* this is to avoid people using g_signal_connect() directly,
* to avoid confusion with local signal names, and because
* of the horribly broken current setup (signals are added
@@ -1514,6 +1627,91 @@
goto out;
}
+typedef struct
+{
+ DBusGProxy *proxy;
+ guint call_id;
+ DBusGProxyCallNotify func;
+ void *data;
+ GDestroyNotify free_data_func;
+} GPendingNotifyClosure;
+
+static void
+d_pending_call_notify (DBusPendingCall *dcall,
+ void *data)
+{
+ GPendingNotifyClosure *closure = data;
+
+ (* closure->func) (closure->proxy, DBUS_G_PROXY_ID_TO_CALL (closure->call_id), closure->data);
+}
+
+static void
+d_pending_call_free (void *data)
+{
+ GPendingNotifyClosure *closure = data;
+
+ if (closure->free_data_func)
+ (* closure->free_data_func) (closure->data);
+
+ g_free (closure);
+}
+
+#define DBUS_G_VALUE_ARRAY_COLLECT_ALL(VALARRAY, FIRST_ARG_TYPE, ARGS) \
+do { \
+ GType valtype; \
+ int i = 0; \
+ VALARRAY = g_value_array_new (6); \
+ valtype = FIRST_ARG_TYPE; \
+ while (valtype != G_TYPE_INVALID) \
+ { \
+ const char *collect_err; \
+ GValue *val; \
+ g_value_array_append (VALARRAY, NULL); \
+ val = g_value_array_get_nth (VALARRAY, i); \
+ g_value_init (val, valtype); \
+ collect_err = NULL; \
+ G_VALUE_COLLECT (val, ARGS, G_VALUE_NOCOPY_CONTENTS, &collect_err); \
+ valtype = va_arg (ARGS, GType); \
+ i++; \
+ } \
+} while (0)
+
+DBusGProxyCall *
+manager_begin_bus_call (DBusGProxyManager *manager,
+ const char *method,
+ DBusGProxyCallNotify notify,
+ gpointer user_data,
+ GDestroyNotify destroy,
+ GType first_arg_type,
+ ...)
+{
+ DBusGProxyCall *call;
+ va_list args;
+ GValueArray *arg_values;
+
+ va_start (args, first_arg_type);
+
+ if (!manager->bus_proxy)
+ {
+ manager->bus_proxy = g_object_new (DBUS_TYPE_G_PROXY,
+ "name", DBUS_SERVICE_DBUS,
+ "path", DBUS_PATH_DBUS,
+ "interface", DBUS_INTERFACE_DBUS,
+ NULL);
+ manager->bus_proxy->manager = manager;
+ }
+
+ DBUS_G_VALUE_ARRAY_COLLECT_ALL (arg_values, first_arg_type, args);
+
+ call = DBUS_G_PROXY_ID_TO_CALL (dbus_g_proxy_begin_call_internal (manager->bus_proxy, method, notify, user_data, destroy, arg_values));
+
+ g_value_array_free (arg_values);
+
+ va_end (args);
+
+ return call;
+}
+
/** @} End of DBusGLibInternals */
/** @addtogroup DBusGLib
@@ -1563,21 +1761,13 @@
g_assert (connection != NULL);
- proxy = g_object_new (DBUS_TYPE_G_PROXY, NULL);
+ proxy = g_object_new (DBUS_TYPE_G_PROXY, "name", name, "path", path_name, "interface", interface_name, NULL);
/* These should all be construct-only mandatory properties,
* for now we just don't let people use g_object_new().
*/
proxy->manager = dbus_g_proxy_manager_get (DBUS_CONNECTION_FROM_G_CONNECTION (connection));
-
- proxy->name = g_strdup (name);
- proxy->path = g_strdup (path_name);
- proxy->interface = g_strdup (interface_name);
-
- proxy->for_owner = (proxy->name[0] == ':');
- proxy->name_call = NULL;
- proxy->associated = FALSE;
dbus_g_proxy_manager_register (proxy->manager, proxy);
@@ -1830,33 +2020,18 @@
return NULL;
}
-#define DBUS_G_VALUE_ARRAY_COLLECT_ALL(VALARRAY, FIRST_ARG_TYPE, ARGS) \
-do { \
- GType valtype; \
- int i = 0; \
- VALARRAY = g_value_array_new (6); \
- valtype = FIRST_ARG_TYPE; \
- while (valtype != G_TYPE_INVALID) \
- { \
- const char *collect_err; \
- GValue *val; \
- g_value_array_append (VALARRAY, NULL); \
- val = g_value_array_get_nth (VALARRAY, i); \
- g_value_init (val, valtype); \
- collect_err = NULL; \
- G_VALUE_COLLECT (val, ARGS, G_VALUE_NOCOPY_CONTENTS, &collect_err); \
- valtype = va_arg (ARGS, GType); \
- i++; \
- } \
-} while (0)
-
-static DBusGPendingCall *
-dbus_g_proxy_begin_call_internal (DBusGProxy *proxy,
- const char *method,
- GValueArray *args)
+static guint
+dbus_g_proxy_begin_call_internal (DBusGProxy *proxy,
+ const char *method,
+ DBusGProxyCallNotify notify,
+ gpointer user_data,
+ GDestroyNotify destroy,
+ GValueArray *args)
{
DBusMessage *message;
DBusPendingCall *pending;
+ GPendingNotifyClosure *closure;
+ guint call_id;
g_return_val_if_fail (DBUS_IS_G_PROXY (proxy), FALSE);
g_return_val_if_fail (!DBUS_G_PROXY_DESTROYED (proxy), FALSE);
@@ -1874,16 +2049,32 @@
goto oom;
g_assert (pending != NULL);
- return DBUS_G_PENDING_CALL_FROM_PENDING_CALL (pending);
+ call_id = ++proxy->call_id_counter;
+
+ if (notify != NULL)
+ {
+ closure = g_new (GPendingNotifyClosure, 1);
+ closure->proxy = proxy; /* No need to ref as the lifecycle is tied to proxy */
+ closure->call_id = call_id;
+ closure->func = notify;
+ closure->data = user_data;
+ closure->free_data_func = destroy;
+ dbus_pending_call_set_notify (pending, d_pending_call_notify,
+ closure,
+ d_pending_call_free);
+ }
+
+ g_hash_table_insert (proxy->pending_calls, GUINT_TO_POINTER (call_id), pending);
+
+ return call_id;
oom:
g_error ("Out of memory");
- return NULL;
+ return 0;
}
static gboolean
-dbus_g_pending_call_end_valist (DBusGConnection *connection,
- DBusGProxy *proxycon,
- DBusGPendingCall *pending,
+dbus_g_proxy_end_call_internal (DBusGProxy *proxy,
+ guint call_id,
GError **error,
GType first_arg_type,
va_list args)
@@ -1896,13 +2087,17 @@
int n_retvals_processed;
gboolean ret;
GType valtype;
+ DBusPendingCall *pending;
reply = NULL;
ret = FALSE;
n_retvals_processed = 0;
over = 0;
- dbus_pending_call_block (DBUS_PENDING_CALL_FROM_G_PENDING_CALL (pending));
- reply = dbus_pending_call_steal_reply (DBUS_PENDING_CALL_FROM_G_PENDING_CALL (pending));
+
+ pending = g_hash_table_lookup (proxy->pending_calls, GUINT_TO_POINTER (call_id));
+
+ dbus_pending_call_block (pending);
+ reply = dbus_pending_call_steal_reply (pending);
g_assert (reply != NULL);
@@ -1921,9 +2116,8 @@
GValue gvalue = { 0, };
DBusGValueMarshalCtx context;
- context.gconnection = connection;
- context.proxy = proxycon;
-
+ context.gconnection = DBUS_G_CONNECTION_FROM_CONNECTION (proxy->manager->connection);
+ context.proxy = proxy;
arg_type = dbus_message_iter_get_arg_type (&msgiter);
if (arg_type == DBUS_TYPE_INVALID)
@@ -2039,76 +2233,44 @@
}
va_end (args_unwind);
- if (pending)
- dbus_g_pending_call_unref (pending);
+ g_hash_table_remove (proxy->pending_calls, GUINT_TO_POINTER (call_id));
+
if (reply)
dbus_message_unref (reply);
return ret;
}
-static gboolean
-dbus_g_pending_call_end (DBusGConnection *connection,
- DBusGProxy *proxycon,
- DBusGPendingCall *pending,
- GError **error,
- GType first_arg_type,
- ...)
-{
- va_list args;
- gboolean ret;
-
- va_start (args, first_arg_type);
-
- ret = dbus_g_pending_call_end_valist (connection, proxycon, pending,
- error, first_arg_type, args);
-
- va_end (args);
-
- return ret;
-}
-
-static gboolean
-dbus_g_proxy_end_call_internal (DBusGProxy *proxy,
- DBusGPendingCall *pending,
- GError **error,
- GType first_arg_type,
- va_list args)
-{
- return dbus_g_pending_call_end_valist (DBUS_G_CONNECTION_FROM_CONNECTION (proxy->manager->connection),
- proxy,
- pending,
- error,
- first_arg_type,
- args);
-}
-
-
/**
- * Invokes a method on a remote interface. This function does not
- * block; instead it returns an opaque #DBusPendingCall object that
- * tracks the pending call. The method call will not be sent over the
- * wire until the application returns to the main loop, or blocks in
- * dbus_connection_flush() to write out pending data. The call will
- * be completed after a timeout, or when a reply is received.
- * To collect the results of the call (which may be an error,
- * or a reply), use dbus_g_proxy_end_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_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().
*
* @todo this particular function shouldn't die on out of memory,
* since you should be able to do a call with large arguments.
*
* @param proxy a proxy for a remote interface
* @param method the name of the method to invoke
+ * @param notify callback to be invoked when method returns
+ * @param user_data user data passed to callback
+ * @param destroy function called to destroy user_data
* @param first_arg_type type of the first argument
*
- * @returns opaque pending call object
+ * @returns call identifier
* */
-DBusGPendingCall*
-dbus_g_proxy_begin_call (DBusGProxy *proxy,
- const char *method,
- GType first_arg_type,
- ...)
+DBusGProxyCall *
+dbus_g_proxy_begin_call (DBusGProxy *proxy,
+ const char *method,
+ DBusGProxyCallNotify notify,
+ gpointer user_data,
+ GDestroyNotify destroy,
+ GType first_arg_type,
+ ...)
{
- DBusGPendingCall *pending;
+ guint call_id;
va_list args;
GValueArray *arg_values;
@@ -2116,21 +2278,21 @@
DBUS_G_VALUE_ARRAY_COLLECT_ALL (arg_values, first_arg_type, args);
- pending = dbus_g_proxy_begin_call_internal (proxy, method, arg_values);
+ call_id = dbus_g_proxy_begin_call_internal (proxy, method, notify, user_data, destroy, arg_values);
g_value_array_free (arg_values);
va_end (args);
- return pending;
+ return DBUS_G_PROXY_ID_TO_CALL (call_id);
}
/**
* Collects the results of a method call. The method call was normally
- * initiated with dbus_g_proxy_end_call(). This function will block if
- * the results haven't yet been received; use
- * dbus_g_pending_call_set_notify() to be notified asynchronously that a
- * pending call has been completed. If it's completed, it will not block.
+ * 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.
*
* If the call results in an error, the error is set as normal for
* GError and the function returns #FALSE.
@@ -2139,17 +2301,15 @@
* method are stored in the provided varargs list.
* The list should be terminated with G_TYPE_INVALID.
*
- * This function unrefs the pending call.
- *
* @param proxy a proxy for a remote interface
- * @param pending the pending call from dbus_g_proxy_begin_call()
+ * @param call_id the pending call ID from dbus_g_proxy_begin_call()
* @param error return location for an error
* @param first_arg_type type of first "out" argument
* @returns #FALSE if an error is set
*/
gboolean
dbus_g_proxy_end_call (DBusGProxy *proxy,
- DBusGPendingCall *pending,
+ DBusGProxyCall *call,
GError **error,
GType first_arg_type,
...)
@@ -2159,7 +2319,7 @@
va_start (args, first_arg_type);
- ret = dbus_g_proxy_end_call_internal (proxy, pending, error, first_arg_type, args);
+ ret = dbus_g_proxy_end_call_internal (proxy, GPOINTER_TO_UINT (call), error, first_arg_type, args);
va_end (args);
@@ -2187,7 +2347,7 @@
...)
{
gboolean ret;
- DBusGPendingCall *pending;
+ guint call_id;
va_list args;
GValueArray *in_args;
@@ -2195,12 +2355,12 @@
DBUS_G_VALUE_ARRAY_COLLECT_ALL (in_args, first_arg_type, args);
- pending = dbus_g_proxy_begin_call_internal (proxy, method, in_args);
+ call_id = dbus_g_proxy_begin_call_internal (proxy, method, NULL, NULL, NULL, in_args);
g_value_array_free (in_args);
first_arg_type = va_arg (args, GType);
- ret = dbus_g_proxy_end_call_internal (proxy, pending, error, first_arg_type, args);
+ ret = dbus_g_proxy_end_call_internal (proxy, call_id, error, first_arg_type, args);
va_end (args);
@@ -2256,6 +2416,35 @@
}
/**
+ * 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.
+ *
+ * @param proxy a proxy for a remote interface
+ * @param call_id the pending call ID from dbus_g_proxy_begin_call()
+ */
+void
+dbus_g_proxy_cancel_call (DBusGProxy *proxy,
+ DBusGProxyCall *call)
+{
+ guint call_id;
+ DBusPendingCall *pending;
+
+ g_return_if_fail (DBUS_IS_G_PROXY (proxy));
+ g_return_if_fail (!DBUS_G_PROXY_DESTROYED (proxy));
+
+ call_id = DBUS_G_PROXY_CALL_TO_ID (call);
+
+ pending = g_hash_table_lookup (proxy->pending_calls, GUINT_TO_POINTER (call_id));
+ g_return_if_fail (pending != NULL);
+
+ dbus_pending_call_cancel (pending);
+
+ g_hash_table_remove (proxy->pending_calls, GUINT_TO_POINTER (call_id));
+}
+
+/**
* 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
Index: dbus-gparser.c
===================================================================
RCS file: /cvs/dbus/dbus/glib/dbus-gparser.c,v
retrieving revision 1.16
retrieving revision 1.17
diff -u -d -r1.16 -r1.17
--- dbus-gparser.c 30 Jun 2005 18:22:10 -0000 1.16
+++ dbus-gparser.c 6 Jul 2005 21:27:49 -0000 1.17
@@ -475,7 +475,7 @@
if (!dbus_signature_validate (str, &derror))
{
- dbus_set_g_error (&derror, error);
+ dbus_set_g_error (error, &derror);
return FALSE;
}
return TRUE;
Index: dbus-gobject.c
===================================================================
RCS file: /cvs/dbus/dbus/glib/dbus-gobject.c,v
retrieving revision 1.38
retrieving revision 1.39
diff -u -d -r1.38 -r1.39
--- dbus-gobject.c 30 Jun 2005 18:22:10 -0000 1.38
+++ dbus-gobject.c 6 Jul 2005 21:27:49 -0000 1.39
@@ -46,7 +46,6 @@
} DBusGErrorInfo;
static GStaticRWLock globals_lock = G_STATIC_RW_LOCK_INIT;
-static GHashTable *info_hash = NULL;
static GHashTable *marshal_table = NULL;
static GData *error_metadata = NULL;
@@ -222,6 +221,16 @@
return string_table_next (data);
}
+static GQuark
+dbus_g_object_type_dbus_metadata_quark (void)
+{
+ static GQuark quark;
+
+ if (!quark)
+ quark = g_quark_from_static_string ("DBusGObjectTypeDBusMetadataQuark");
+ return quark;
+}
+
static const DBusGObjectInfo *
lookup_object_info (GObject *object)
{
@@ -230,16 +239,11 @@
ret = NULL;
- g_static_rw_lock_reader_lock (&globals_lock);
-
- if (info_hash == NULL)
- goto out;
-
for (classtype = G_TYPE_FROM_INSTANCE (object); classtype != 0; classtype = g_type_parent (classtype))
{
const DBusGObjectInfo *info;
- info = g_hash_table_lookup (info_hash, g_type_class_peek (classtype));
+ info = g_type_get_qdata (classtype, dbus_g_object_type_dbus_metadata_quark ());
if (info != NULL && info->format_version == 0)
{
@@ -248,9 +252,6 @@
}
}
- out:
- g_static_rw_lock_reader_unlock (&globals_lock);
-
return ret;
}
@@ -1355,28 +1356,13 @@
dbus_g_object_type_install_info (GType object_type,
const DBusGObjectInfo *info)
{
- GObjectClass *object_class;
-
- g_return_if_fail (G_TYPE_IS_OBJECT (object_type));
+ g_return_if_fail (G_TYPE_IS_CLASSED (object_type));
dbus_g_value_types_init ();
- object_class = g_type_class_ref (object_type);
-
- g_return_if_fail (G_IS_OBJECT_CLASS (object_class));
-
- g_static_rw_lock_writer_lock (&globals_lock);
-
- if (info_hash == NULL)
- {
- info_hash = g_hash_table_new (NULL, NULL); /* direct hash */
- }
-
- g_hash_table_replace (info_hash, object_class, (void*) info);
-
- g_static_rw_lock_writer_unlock (&globals_lock);
-
- g_type_class_unref (object_class);
+ g_type_set_qdata (object_type,
+ dbus_g_object_type_dbus_metadata_quark (),
+ (gpointer) info);
}
/**
Index: dbus-glib.c
===================================================================
RCS file: /cvs/dbus/dbus/glib/dbus-glib.c,v
retrieving revision 1.7
retrieving revision 1.8
diff -u -d -r1.7 -r1.8
--- dbus-glib.c 30 Jun 2005 18:22:10 -0000 1.7
+++ dbus-glib.c 6 Jul 2005 21:27:49 -0000 1.8
@@ -112,30 +112,6 @@
}
/**
- * Increments refcount on a pending call.
- *
- * @param call the call
- * @returns the same call
- */
-DBusGPendingCall*
-dbus_g_pending_call_ref (DBusGPendingCall *call)
-{
- dbus_pending_call_ref (DBUS_PENDING_CALL_FROM_G_PENDING_CALL (call));
- return call;
-}
-
-/**
- * Decrements refcount on a pending call.
- *
- * @param call the call
- */
-void
-dbus_g_pending_call_unref (DBusGPendingCall *call)
-{
- dbus_pending_call_unref (DBUS_PENDING_CALL_FROM_G_PENDING_CALL (call));
-}
-
-/**
* The implementation of DBUS_GERROR error domain. See documentation
* for GError in GLib reference manual.
*
@@ -235,24 +211,6 @@
}
/**
- * Get the GLib type ID for a DBusPendingCall boxed type.
- *
- * @returns GLib type
- */
-GType
-dbus_pending_call_get_g_type (void)
-{
- static GType our_type = 0;
-
- if (our_type == 0)
- our_type = g_boxed_type_register_static ("DBusPendingCall",
- (GBoxedCopyFunc) dbus_pending_call_ref,
- (GBoxedFreeFunc) dbus_pending_call_unref);
-
- return our_type;
-}
-
-/**
* Get the GLib type ID for a DBusGConnection boxed type.
*
* @returns GLib type
@@ -289,24 +247,6 @@
}
/**
- * Get the GLib type ID for a DBusGPendingCall boxed type.
- *
- * @returns GLib type
- */
-GType
-dbus_g_pending_call_get_g_type (void)
-{
- static GType our_type = 0;
-
- if (our_type == 0)
- our_type = g_boxed_type_register_static ("DBusGPendingCall",
- (GBoxedCopyFunc) dbus_g_pending_call_ref,
- (GBoxedFreeFunc) dbus_g_pending_call_unref);
-
- return our_type;
-}
-
-/**
* Get the DBusConnection corresponding to this DBusGConnection.
* The return value does not have its refcount incremented.
*
@@ -330,86 +270,6 @@
return DBUS_MESSAGE_FROM_G_MESSAGE (gmessage);
}
-typedef struct
-{
- DBusGPendingCallNotify func;
- void *data;
- GDestroyNotify free_data_func;
-} GPendingNotifyClosure;
-
-static void
-d_pending_call_notify (DBusPendingCall *dcall,
- void *data)
-{
- GPendingNotifyClosure *closure = data;
- DBusGPendingCall *gcall = DBUS_G_PENDING_CALL_FROM_PENDING_CALL (dcall);
-
- (* closure->func) (gcall, closure->data);
-}
-
-static void
-d_pending_call_free (void *data)
-{
- GPendingNotifyClosure *closure = data;
-
- if (closure->free_data_func)
- (* closure->free_data_func) (closure->data);
-
- g_free (closure);
-}
-
-/**
- * Sets up a notification to be invoked when the pending call
- * is ready to be ended without blocking.
- * You can call dbus_g_proxy_end_call() at any time,
- * but it will block if no reply or error has been received yet.
- * This function lets you handle the reply asynchronously.
- *
- * @param call the pending call
- * @param callback the callback
- * @param callback_data data for the callback
- * @param free_data_func free the callback data with this
- */
-void
-dbus_g_pending_call_set_notify (DBusGPendingCall *call,
- DBusGPendingCallNotify callback,
- void *callback_data,
- GDestroyNotify free_data_func)
-{
- GPendingNotifyClosure *closure;
- DBusPendingCall *dcall;
-
- g_return_if_fail (callback != NULL);
-
- closure = g_new (GPendingNotifyClosure, 1);
-
- closure->func = callback;
- closure->data = callback_data;
- closure->free_data_func = free_data_func;
-
- dcall = DBUS_PENDING_CALL_FROM_G_PENDING_CALL (call);
- dbus_pending_call_set_notify (dcall, d_pending_call_notify,
- closure,
- d_pending_call_free);
-}
-
-/**
- * Cancels a pending call. Does not affect the reference count
- * of the call, but it means you will never be notified of call
- * completion, and can't call dbus_g_proxy_end_call().
- *
- * @param call the call
- */
-void
-dbus_g_pending_call_cancel (DBusGPendingCall *call)
-{
- DBusPendingCall *dcall;
-
- dcall = DBUS_PENDING_CALL_FROM_G_PENDING_CALL (call);
-
- dbus_pending_call_cancel (dcall);
-}
-
/** @} */ /* end of public API */
Index: dbus-binding-tool-glib.c
===================================================================
RCS file: /cvs/dbus/dbus/glib/dbus-binding-tool-glib.c,v
retrieving revision 1.14
retrieving revision 1.15
diff -u -d -r1.14 -r1.15
--- dbus-binding-tool-glib.c 29 Jun 2005 23:52:35 -0000 1.14
+++ dbus-binding-tool-glib.c 6 Jul 2005 21:27:49 -0000 1.15
@@ -1350,7 +1350,9 @@
WRITE_OR_LOSE ("G_TYPE_INVALID);\n}\n\n");
+#if 0
write_async_method_client (channel, interface, method, error);
+#endif
}
if (!write_printf_to_iochannel ("#endif /* defined DBUS_GLIB_CLIENT_WRAPPERS_%s */\n\n", channel, error, iface_prefix))
More information about the dbus-commit
mailing list