+2003-08-14 Havoc Pennington <hp@redhat.com>
+
+ * dbus/dbus-pending-call.c: start on new object that will replace
+ DBusMessageHandler and ReplyHandlerData for tracking outstanding
+ replies
+
+ * dbus/dbus-gproxy.c: start on proxy object used to communicate
+ with remote interfaces
+
+ * dbus/dbus-gidl.c: do the boring boilerplate in here
+
2003-08-12 Havoc Pennington <hp@pobox.com>
* bus/dispatch.c (bus_dispatch): make this return proper
--- /dev/null
+/* -*- mode: C; c-file-style: "gnu" -*- */
+/* dbus-pending-call.c Object representing a call in progress.
+ *
+ * Copyright (C) 2002, 2003 Red Hat Inc.
+ *
+ * Licensed under the Academic Free License version 1.2
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+#include "dbus-internals.h"
+#include "dbus-message-pending.h"
+#include "dbus-list.h"
+#include "dbus-threads.h"
+#include "dbus-test.h"
+#include "dbus-connection-internal.h"
+
+/**
+ * @defgroup DBusPendingCallInternals DBusPendingCall implementation details
+ * @ingroup DBusInternals
+ * @brief DBusPendingCall private implementation details.
+ *
+ * The guts of DBusPendingCall and its methods.
+ *
+ * @{
+ */
+
+/**
+ * @brief Internals of DBusPendingCall
+ *
+ * Object representing a reply message that we're waiting for.
+ */
+struct DBusPendingCall
+{
+ DBusAtomic refcount; /**< reference count */
+
+ DBusPendingCallNotifyFunction function; /**< Notifier when reply arrives. */
+ void *user_data; /**< user data for function */
+ DBusFreeFunction free_user_data; /**< free the user data */
+
+ DBusConnection *connection; /**< Connections we're associated with */
+ DBusMessage *reply; /**< Reply (after we've received it) */
+ DBusTimeout *timeout; /**< Timeout */
+
+ DBusList *timeout_link; /**< Preallocated timeout response */
+
+ dbus_uint32_t reply_serial; /**< Expected serial of reply */
+
+ unsigned int completed : 1; /**< TRUE if completed */
+ unsigned int timeout_added : 1; /**< Have added the timeout */
+};
+
+/**
+ * Creates a new pending reply object.
+ *
+ * @param connection connection where reply will arrive
+ * @param reply_serial reply serial of the expected reply
+ * @returns a new #DBusPendingCall or #NULL if no memory.
+ */
+DBusPendingCall*
+_dbus_pending_call_new (DBusConnection *connection,
+ dbus_uint32_t reply_serial)
+{
+ DBusPendingCall *pending;
+
+ pending = dbus_new (DBusPendingCall, 1);
+
+ if (pending == NULL)
+ return NULL;
+
+ pending->refcount.value = 1;
+ pending->connection = connection;
+ pending->reply_serial = reply_serial;
+
+ return pending;
+}
+
+/** @} */
+
+/**
+ * @defgroup DBusPendingCall DBusPendingCall
+ * @ingroup DBus
+ * @brief Pending reply to a method call message
+ *
+ * A DBusPendingCall is an object representing an
+ * expected reply. A #DBusPendingCall can be created
+ * when you send a message that should have a reply.
+ *
+ * @{
+ */
+
+/**
+ * @typedef DBusPendingCall
+ *
+ * Opaque data type representing a message pending.
+ */
+
+/**
+ * Increments the reference count on a pending call.
+ *
+ * @param pending the pending call object
+ */
+void
+dbus_pending_call_ref (DBusPendingCall *pending)
+{
+ _dbus_return_if_fail (pending != NULL);
+
+ _dbus_atomic_inc (&pending->refcount);
+}
+
+/**
+ * Decrements the reference count on a pending call,
+ * freeing it if the count reaches 0.
+ *
+ * @param pending the pending call object
+ */
+void
+dbus_pending_call_unref (DBusPendingCall *pending)
+{
+ dbus_bool_t last_unref;
+
+ _dbus_return_if_fail (pending != NULL);
+
+ last_unref = (_dbus_atomic_dec (&pending->refcount) == 1);
+
+ if (last_unref)
+ {
+ if (pending->free_user_data)
+ (* pending->free_user_data) (pending->user_data);
+
+
+ if (pending->connection != NULL)
+ {
+ _dbus_connection_pending_destroyed_locked (connection, pending);
+ pending->connection = NULL;
+ }
+
+ if (pending->reply)
+ {
+ dbus_message_unref (pending->reply);
+ pending->reply = NULL;
+ }
+
+ dbus_free (pending);
+ }
+}
+
+/**
+ * Sets a notification function to be called when the reply is
+ * received or the pending call times out.
+ *
+ * @param pending the pending call
+ * @param function notifier function
+ * @param user_data data to pass to notifier function
+ * @param free_user_data function to free the user data
+ *
+ */
+void
+dbus_pending_call_set_notify (DBusPendingCall *pending,
+ DBusPendingCallNotifyFunction function,
+ void *user_data,
+ DBusFreeFunction free_user_data)
+{
+ DBusFreeFunction old_free_func;
+ void *old_user_data;
+
+ _dbus_return_if_fail (pending != NULL);
+
+ _DBUS_LOCK (pending_call);
+ old_free_func = pending->free_user_data;
+ old_user_data = pending->user_data;
+
+ pending->user_data = user_data;
+ pending->free_user_data = free_user_data;
+ pending->function = function;
+ _DBUS_UNLOCK (pending_call);
+
+ if (old_free_func)
+ (* old_free_func) (old_user_data);
+}
+
+/** @} */
+
+#ifdef DBUS_BUILD_TESTS
+static DBusPendingResult
+test_pending (DBusPendingCall *pending,
+ DBusConnection *connection,
+ DBusMessage *message,
+ void *user_data)
+{
+ return DBUS_PENDING_RESULT_NOT_YET_HANDLED;
+}
+
+static void
+free_test_data (void *data)
+{
+ /* does nothing */
+}
+
+/**
+ * @ingroup DBusPendingCallInternals
+ * Unit test for DBusPendingCall.
+ *
+ * @returns #TRUE on success.
+ */
+dbus_bool_t
+_dbus_pending_call_test (const char *test_data_dir)
+{
+
+ return TRUE;
+}
+#endif /* DBUS_BUILD_TESTS */
--- /dev/null
+/* -*- mode: C; c-file-style: "gnu" -*- */
+/* dbus-pending-call.h Object representing a call in progress.
+ *
+ * Copyright (C) 2002, 2003 Red Hat Inc.
+ *
+ * Licensed under the Academic Free License version 1.2
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+#if !defined (DBUS_INSIDE_DBUS_H) && !defined (DBUS_COMPILATION)
+#error "Only <dbus/dbus.h> can be included directly, this file may disappear or change contents."
+#endif
+
+#ifndef DBUS_PENDING_CALL_H
+#define DBUS_PENDING_CALL_H
+
+#include <dbus/dbus-macros.h>
+#include <dbus/dbus-types.h>
+#include <dbus/dbus-connection.h>
+
+DBUS_BEGIN_DECLS;
+
+typedef void (* DBusPendingCallNotifyFunction) (DBusPendingCall *pending,
+ void *user_data);
+
+DBusPendingCall* _dbus_pending_call_new (DBusConnection *connection,
+ dbus_uint32_t reply_serial);
+
+void dbus_pending_call_ref (DBusPendingCall *pending);
+void dbus_pending_call_unref (DBusPendingCall *pending);
+void dbus_pending_call_set_notify (DBusPendingCall *pending,
+ DBusPendingCallNotifyFunction function,
+ void *user_data,
+ DBusFreeFunction free_user_data);
+dbus_bool_t dbus_pending_call_get_completed (DBusPendingCall *pending);
+DBusMessage* dbus_pending_call_get_reply (DBusPendingCall *pending);
+
+
+
+DBUS_END_DECLS;
+
+#endif /* DBUS_PENDING_CALL_H */
-INCLUDES=-I$(top_srcdir) $(DBUS_CLIENT_CFLAGS) $(DBUS_GLIB_CFLAGS)
+INCLUDES=-I$(top_srcdir) $(DBUS_CLIENT_CFLAGS) $(DBUS_GLIB_CFLAGS) -DDBUS_COMPILATION=1
dbusincludedir=$(includedir)/dbus-1.0/dbus
lib_LTLIBRARIES=libdbus-glib-1.la
dbusinclude_HEADERS= \
- dbus-glib.h
+ dbus-glib.h \
+ dbus-gproxy.h
libdbus_glib_1_la_SOURCES = \
dbus-gmain.c \
+ dbus-gproxy.c \
dbus-gthread.c
libdbus_glib_1_la_LIBADD= $(DBUS_GLIB_LIBS) $(top_builddir)/dbus/libdbus-1.la
+bin_PROGRAMS=dbus-glib-compiler
+
+dbus_glib_compiler_SOURCES = \
+ dbus-gidl.c \
+ dbus-gidl.h \
+ dbus-compiler-main.c
+
+dbus_glib_compiler_LDADD= libdbus-glib-1.la $(DBUS_GLIB_LIBS) $(top_builddir)/dbus/libdbus-1.la
+
if DBUS_BUILD_TESTS
if HAVE_GLIB_THREADS
--- /dev/null
+/* -*- mode: C; c-file-style: "gnu" -*- */
+/* dbus-compiler-main.c main() for GLib stubs/skels generator
+ *
+ * Copyright (C) 2003 Red Hat, Inc.
+ *
+ * Licensed under the Academic Free License version 1.2
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+#include "dbus-gidl.h"
+
+int
+main (int argc, char **argv)
+{
+
+
+ return 0;
+}
+
+#ifdef DBUS_BUILD_TESTS
+
+/**
+ * @ingroup DBusGCompiler
+ * Unit test for GLib stubs/skels compiler
+ * @returns #TRUE on success.
+ */
+dbus_bool_t
+_dbus_gcompiler_test (void)
+{
+
+ return TRUE;
+}
+
+#endif /* DBUS_BUILD_TESTS */
--- /dev/null
+/* -*- mode: C; c-file-style: "gnu" -*- */
+/* dbus-gidl.c data structure describing an interface, to be generated from IDL
+ * or something
+ *
+ * Copyright (C) 2003 Red Hat, Inc.
+ *
+ * Licensed under the Academic Free License version 1.2
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+#include "dbus-gidl.h"
+
+struct InterfaceInfo
+{
+ int refcount;
+ char *name;
+ GSList *methods;
+ GSList *signals;
+};
+
+struct MethodInfo
+{
+ int refcount;
+ GSList *args;
+ char *name;
+ MethodStyle style;
+};
+
+struct SignalInfo
+{
+ int refcount;
+ GSList *args;
+ char *name;
+};
+
+struct ArgInfo
+{
+ int refcount;
+ char *name;
+ int type;
+ ArgDirection direction;
+};
+
+static void
+free_method_list (GSList **methods_p)
+{
+ GSList *tmp;
+ tmp = *methods_p;
+ while (tmp != NULL)
+ {
+ method_info_unref (tmp->data);
+ tmp = tmp->next;
+ }
+ g_slist_free (*methods_p);
+ *methods_p = NULL;
+}
+
+static void
+free_signal_list (GSList **signals_p)
+{
+ GSList *tmp;
+ tmp = *signals_p;
+ while (tmp != NULL)
+ {
+ signal_info_unref (tmp->data);
+ tmp = tmp->next;
+ }
+ g_slist_free (*signals_p);
+ *signals_p = NULL;
+}
+
+InterfaceInfo*
+interface_info_new (const char *name)
+{
+ InterfaceInfo *info;
+
+ info = g_new0 (InterfaceInfo, 1);
+ info->refcount = 1;
+ info->name = g_strdup (name);
+
+ return info;
+}
+
+void
+interface_info_ref (InterfaceInfo *info)
+{
+ info->refcount += 1;
+}
+
+void
+interface_info_unref (InterfaceInfo *info)
+{
+ info->refcount -= 1;
+ if (info->refcount == 0)
+ {
+ free_method_list (&info->methods);
+ free_signal_list (&info->signals);
+ g_free (info->name);
+ g_free (info);
+ }
+}
+
+GSList*
+interface_info_get_methods (InterfaceInfo *info)
+{
+ return info->methods;
+}
+
+GSList*
+interface_info_get_signals (InterfaceInfo *info)
+{
+ return info->signals;
+}
+
+void
+interface_info_add_method (InterfaceInfo *info,
+ MethodInfo *method)
+{
+ method_info_ref (method);
+ info->methods = g_slist_append (info->methods, method);
+}
+
+void
+interface_info_add_signal (InterfaceInfo *info,
+ SignalInfo *signal)
+{
+ signal_info_ref (signal);
+ info->signals = g_slist_append (info->signals, signal);
+}
+
+static void
+free_arg_list (GSList **args_p)
+{
+ GSList *tmp;
+ tmp = *args_p;
+ while (tmp != NULL)
+ {
+ arg_info_unref (tmp->data);
+ tmp = tmp->next;
+ }
+ g_slist_free (*args_p);
+ *args_p = NULL;
+}
+
+MethodInfo*
+method_info_new (const char *name,
+ MethodStyle style)
+{
+ MethodInfo *info;
+
+ info = g_new0 (MethodInfo, 1);
+ info->refcount = 1;
+ info->name = g_strdup (name);
+ info->style = style;
+
+ return info;
+}
+
+void
+method_info_ref (MethodInfo *info)
+{
+ info->refcount += 1;
+}
+
+void
+method_info_unref (MethodInfo *info)
+{
+ info->refcount -= 1;
+ if (info->refcount == 0)
+ {
+ free_arg_list (&info->args);
+ g_free (info->name);
+ g_free (info);
+ }
+}
+
+const char*
+method_info_get_name (MethodInfo *info)
+{
+ return info->name;
+}
+
+GSList*
+method_info_get_args (MethodInfo *info)
+{
+ return info->args;
+}
+
+MethodStyle
+method_info_get_style (MethodInfo *info)
+{
+ return info->style;
+}
+
+void
+method_info_add_arg (MethodInfo *info,
+ ArgInfo *arg)
+{
+ arg_info_ref (arg);
+ info->args = g_slist_append (info->args, arg);
+}
+
+SignalInfo*
+signal_info_new (const char *name)
+{
+ SignalInfo *info;
+
+ info = g_new0 (SignalInfo, 1);
+ info->refcount = 1;
+ info->name = g_strdup (name);
+
+ return info;
+}
+
+void
+signal_info_ref (SignalInfo *info)
+{
+ info->refcount += 1;
+}
+
+void
+signal_info_unref (SignalInfo *info)
+{
+ info->refcount -= 1;
+ if (info->refcount == 0)
+ {
+ free_arg_list (&info->args);
+ g_free (info->name);
+ g_free (info);
+ }
+}
+
+const char*
+signal_info_get_name (SignalInfo *info)
+{
+ return info->name;
+}
+
+GSList*
+signal_info_get_args (SignalInfo *info)
+{
+ return info->args;
+}
+
+void
+signal_info_add_arg (SignalInfo *info,
+ ArgInfo *arg)
+{
+ arg_info_ref (arg);
+ info->args = g_slist_append (info->args, arg);
+}
+
+ArgInfo*
+arg_info_new (const char *name,
+ ArgDirection direction,
+ int type)
+{
+ ArgInfo *info;
+
+ info = g_new0 (ArgInfo, 1);
+ info->refcount = 1;
+ info->name = g_strdup (name);
+ info->direction = direction;
+ info->type = type;
+
+ return info;
+}
+
+void
+arg_info_ref (ArgInfo *info)
+{
+ info->refcount += 1;
+}
+
+void
+arg_info_unref (ArgInfo *info)
+{
+ info->refcount -= 1;
+ if (info->refcount == 0)
+ {
+ g_free (info->name);
+ g_free (info);
+ }
+}
+const char*
+arg_info_get_name (ArgInfo *info)
+{
+ return info->name;
+}
+
+int
+arg_info_get_type (ArgInfo *info)
+{
+ return info->type;
+}
+
+ArgDirection
+arg_info_get_direction (ArgInfo *info)
+{
+ return info->direction;
+}
+
+#ifdef DBUS_BUILD_TESTS
+
+/**
+ * @ingroup DBusGIDL
+ * Unit test for GLib IDL internals
+ * @returns #TRUE on success.
+ */
+dbus_bool_t
+_dbus_gidl_test (void)
+{
+
+ return TRUE;
+}
+
+#endif /* DBUS_BUILD_TESTS */
METHOD_CANCELLABLE
} MethodStyle;
-InterfaceInfo* interface_info_new (void);
+InterfaceInfo* interface_info_new (const char *name);
void interface_info_ref (InterfaceInfo *info);
void interface_info_unref (InterfaceInfo *info);
GSList* interface_info_get_methods (InterfaceInfo *info);
GSList* interface_info_get_signals (InterfaceInfo *info);
+void interface_info_add_method (InterfaceInfo *info,
+ MethodInfo *method);
+void interface_info_add_signal (InterfaceInfo *info,
+ SignalInfo *signal);
-MethodInfo* method_info_new (void);
+MethodInfo* method_info_new (const char *name,
+ MethodStyle style);
void method_info_ref (MethodInfo *info);
void method_info_unref (MethodInfo *info);
const char* method_info_get_name (MethodInfo *info);
GSList* method_info_get_args (MethodInfo *info);
MethodStyle method_info_get_style (MethodInfo *info);
+void method_info_add_arg (MethodInfo *info,
+ ArgInfo *arg);
-SignalInfo* signal_info_new (void);
+SignalInfo* signal_info_new (const char *name);
void signal_info_ref (SignalInfo *info);
void signal_info_unref (SignalInfo *info);
const char* signal_info_get_name (SignalInfo *info);
GSList* signal_info_get_args (SignalInfo *info);
+void signal_info_add_arg (SignalInfo *info,
+ ArgInfo *arg);
-ArgInfo* arg_info_new (void);
+ArgInfo* arg_info_new (const char *name,
+ ArgDirection direction,
+ int type);
void arg_info_ref (ArgInfo *info);
void arg_info_unref (ArgInfo *info);
const char* arg_info_get_name (ArgInfo *info);
G_BEGIN_DECLS
+#define DBUS_INSIDE_DBUS_GLIB_H 1
+
void dbus_gthread_init (void);
void dbus_connection_setup_with_g_main (DBusConnection *connection,
GMainContext *context);
void dbus_server_setup_with_g_main (DBusServer *server,
GMainContext *context);
+#undef DBUS_INSIDE_DBUS_GLIB_H
+
G_END_DECLS
#endif /* DBUS_GLIB_H */
--- /dev/null
+/* -*- mode: C; c-file-style: "gnu" -*- */
+/* dbus-gcall.c convenience routines for calling methods, etc.
+ *
+ * Copyright (C) 2003 Red Hat, Inc.
+ *
+ * Licensed under the Academic Free License version 1.2
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+#include "dbus-gproxy.h"
+
+/**
+ * @addtogroup DBusGLibInternals
+ *
+ * @{
+ */
+
+struct DBusGProxy
+{
+ int refcount;
+ DBusConnection *connection;
+ char *service;
+ char *interface;
+ DBusObjectID object_id;
+};
+
+static DBusGProxy*
+_dbus_gproxy_new (DBusConnection *connection)
+{
+ DBusGProxy *proxy;
+
+ proxy = g_new0 (DBusGProxy, 1);
+
+ proxy->refcount = 1;
+ proxy->connection = connection;
+ dbus_connection_ref (connection);
+
+ return proxy;
+}
+
+/** @} End of DBusGLibInternals */
+
+/** @addtogroup DBusGLib
+ * @{
+ */
+
+/**
+ * Creates a new proxy for a remote interface. Method calls and signal
+ * connections over this proxy will go to the service owner; the
+ * service owner is expected to support the given interface name. THE
+ * SERVICE OWNER MAY CHANGE OVER TIME, for example between two
+ * different method calls. If you need a fixed owner, you need to
+ * request the current owner and bind a proxy to that rather than to
+ * the generic service name; see dbus_gproxy_new_for_service_owner().
+ *
+ * A service-associated proxy only makes sense with a message bus,
+ * not for app-to-app direct dbus connections.
+ *
+ * @param connection the connection to the remote bus or app
+ * @param service_name name of the service on the message bus
+ * @param interface_name name of the interface to call methods on
+ * @returns new proxy object
+ */
+DBusGProxy*
+dbus_gproxy_new_for_service (DBusConnection *connection,
+ const char *service_name,
+ const char *interface_name)
+{
+ DBusGProxy *proxy;
+
+ g_return_val_if_fail (connection != NULL, NULL);
+ g_return_val_if_fail (service_name != NULL, NULL);
+ g_return_val_if_fail (interface_name != NULL, NULL);
+
+ proxy = _dbus_gproxy_new (connection);
+
+ proxy->service = g_strdup (service_name);
+ proxy->interface = g_strdup (interface_name);
+
+ return proxy;
+}
+
+/**
+ * Increment reference count on proxy object.
+ *
+ * @param proxy the proxy
+ */
+void
+dbus_gproxy_ref (DBusGProxy *proxy)
+{
+ g_return_if_fail (proxy != NULL);
+
+ proxy->refcount += 1;
+}
+
+/**
+ * Decrement reference count on proxy object.
+ *
+ * @param proxy the proxy
+ */
+void
+dbus_gproxy_unref (DBusGProxy *proxy)
+{
+ g_return_if_fail (proxy != NULL);
+
+ proxy->refcount -= 1;
+ if (proxy->refcount == 0)
+ {
+ dbus_connection_unref (proxy->connection);
+ g_free (proxy->interface);
+ g_free (proxy->service);
+ g_free (proxy);
+ }
+}
+
+/**
+ * Invokes a method on a remote interface. This function does not
+ * block; instead it returns an opaque #DBusGPendingCall 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.
+ *
+ * @param proxy a proxy for a remote interface
+ * @param method the name of the method to invoke
+ * @param first_arg_type type of the first argument
+ *
+ * @returns opaque pending call object
+ *
+ */
+DBusGPendingCall*
+dbus_gproxy_begin_call (DBusGProxy *proxy,
+ const char *method,
+ int first_arg_type,
+ ...)
+{
+
+
+}
+
+/** @} End of DBusGLib public */
+
+#ifdef DBUS_BUILD_TESTS
+
+/**
+ * @ingroup DBusGLibInternals
+ * Unit test for GLib proxy functions
+ * @returns #TRUE on success.
+ */
+dbus_bool_t
+_dbus_gproxy_test (void)
+{
+
+ return TRUE;
+}
+
+#endif /* DBUS_BUILD_TESTS */
--- /dev/null
+/* -*- mode: C; c-file-style: "gnu" -*- */
+/* dbus-gproxy.h convenience routines for calling methods, etc.
+ *
+ * Copyright (C) 2003 Red Hat, Inc.
+ *
+ * Licensed under the Academic Free License version 1.2
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+#ifndef DBUS_GPROXY_H
+#define DBUS_GPROXY_H
+
+#if !defined (DBUS_INSIDE_DBUS_GLIB_H) && !defined (DBUS_COMPILATION)
+#error "Only <dbus/dbus-glib.h> can be included directly, this file may disappear or change contents."
+#endif
+
+#include <dbus/dbus.h>
+#include <glib.h>
+#include <glib-object.h> /* for GCallback at the moment, we don't link to it */
+
+G_BEGIN_DECLS
+
+typedef struct DBusGProxy DBusGProxy;
+typedef struct DBusGPendingCall DBusGPendingCall;
+
+DBusGProxy* dbus_gproxy_new_for_service (DBusConnection *connection,
+ const char *service_name,
+ const char *interface_name);
+DBusGProxy* dbus_gproxy_new_for_service_owner (DBusConnection *connection,
+ const char *service_name,
+ const char *interface_name,
+ GError **error);
+DBusGProxy* dbus_gproxy_new_for_object_id (DBusConnection *connection,
+ const DBusObjectID *object_id,
+ const char *interface_name);
+DBusGProxy* dbus_gproxy_new_for_interface (DBusConnection *connection,
+ const char *interface_name);
+void dbus_gproxy_ref (DBusGProxy *proxy);
+void dbus_gproxy_unref (DBusGProxy *proxy);
+gboolean dbus_gproxy_connect_signal (DBusGProxy *proxy,
+ const char *signal_name,
+ GCallback callback,
+ void *data,
+ GFreeFunc free_data_func,
+ GError **error);
+DBusGPendingCall* dbus_gproxy_begin_call (DBusGProxy *proxy,
+ const char *method,
+ int first_arg_type,
+ ...);
+void dbus_gproxy_oneway_call (DBusGProxy *proxy,
+ const char *method,
+ int first_arg_type,
+ ...);
+
+gboolean dbus_gpending_call_is_complete (DBusGPendingCall *call);
+void dbus_gpending_call_cancel_and_free (DBusGPendingCall *call);
+gboolean dbus_gpending_call_block_and_free (DBusGPendingCall *call,
+ GError **error,
+ int first_arg_type,
+ ...);
+
+
+
+G_END_DECLS
+
+#endif /* DBUS_GPROXY_H */
projects / platform / upstream / dbus.git / commitdiff