From 2207a081359d281b778bd4816510025666de02d7 Mon Sep 17 00:00:00 2001 From: Xavier Claessens Date: Sat, 11 Jun 2011 08:09:13 +0200 Subject: [PATCH] Add TpSimpleClientFactory This is a new object replacing TpBasicProxyFactory but can construct any known TpProxy subclasses, guarantee their uniqueness per object-path and keep a user-defined set of features to prepare on them. --- docs/reference/telepathy-glib-docs.sgml | 1 + docs/reference/telepathy-glib-sections.txt | 33 + telepathy-glib/Makefile.am | 3 + telepathy-glib/account-manager.c | 9 + telepathy-glib/account.c | 11 + telepathy-glib/channel.c | 13 + telepathy-glib/connection.c | 13 + telepathy-glib/introspection.am | 1 + telepathy-glib/proxy.c | 49 ++- telepathy-glib/proxy.h | 4 + telepathy-glib/simple-client-factory-internal.h | 44 ++ telepathy-glib/simple-client-factory.c | 848 +++++++++++++++++++++++ telepathy-glib/simple-client-factory.h | 141 ++++ telepathy-glib/telepathy-glib.h | 1 + 14 files changed, 1170 insertions(+), 1 deletions(-) create mode 100644 telepathy-glib/simple-client-factory-internal.h create mode 100644 telepathy-glib/simple-client-factory.c create mode 100644 telepathy-glib/simple-client-factory.h diff --git a/docs/reference/telepathy-glib-docs.sgml b/docs/reference/telepathy-glib-docs.sgml index dd76210..006e11c 100644 --- a/docs/reference/telepathy-glib-docs.sgml +++ b/docs/reference/telepathy-glib-docs.sgml @@ -81,6 +81,7 @@ + diff --git a/docs/reference/telepathy-glib-sections.txt b/docs/reference/telepathy-glib-sections.txt index d3e8757..a02e4da 100644 --- a/docs/reference/telepathy-glib-sections.txt +++ b/docs/reference/telepathy-glib-sections.txt @@ -2958,6 +2958,7 @@ TpProxyPendingCall tp_proxy_pending_call_cancel TpProxySignalConnection tp_proxy_signal_connection_disconnect +tp_proxy_get_factory tp_proxy_get_dbus_daemon tp_proxy_get_dbus_connection tp_proxy_get_bus_name @@ -5678,3 +5679,35 @@ TP_TYPE_FILE_TRANSFER_CHANNEL TpFileTransferChannelPrivate tp_file_transfer_channel_get_feature_quark_core + +
+simple-client-factory +simple-client-factory +telepathy-glib/telepathy-glib.h +TpSimpleClientFactory +TpSimpleClientFactoryClass +tp_simple_client_factory_new +tp_simple_client_factory_get_dbus_daemon +tp_simple_client_factory_dup_account_manager +tp_simple_client_factory_dup_account +tp_simple_client_factory_dup_account_features +tp_simple_client_factory_add_account_features +tp_simple_client_factory_dup_connection +tp_simple_client_factory_dup_connection_features +tp_simple_client_factory_add_connection_features +tp_simple_client_factory_dup_channel +tp_simple_client_factory_dup_channel_features +tp_simple_client_factory_add_channel_features +tp_simple_client_factory_dup_contact +tp_simple_client_factory_dup_contact_features +tp_simple_client_factory_add_contact_features + +TP_IS_SIMPLE_CLIENT_FACTORY +TP_IS_SIMPLE_CLIENT_FACTORY_CLASS +TP_SIMPLE_CLIENT_FACTORY +TP_SIMPLE_CLIENT_FACTORY_CLASS +TP_SIMPLE_CLIENT_FACTORY_GET_CLASS +TP_TYPE_SIMPLE_CLIENT_FACTORY +tp_simple_client_factory_get_type +TpSimpleClientFactoryPrivate +
diff --git a/telepathy-glib/Makefile.am b/telepathy-glib/Makefile.am index d1a6a44..aa47439 100644 --- a/telepathy-glib/Makefile.am +++ b/telepathy-glib/Makefile.am @@ -89,6 +89,7 @@ our_headers = \ run.h \ signalled-message.h \ simple-approver.h \ + simple-client-factory.h \ simple-handler.h \ simple-observer.h \ simple-password-manager.h \ @@ -235,6 +236,8 @@ libtelepathy_glib_internal_la_SOURCES = \ signalled-message.c \ signalled-message-internal.h \ simple-approver.c \ + simple-client-factory.c \ + simple-client-factory-internal.h \ simple-handler.c \ simple-observer.c \ simple-password-manager.c \ diff --git a/telepathy-glib/account-manager.c b/telepathy-glib/account-manager.c index 1e3802f..1feee6d 100644 --- a/telepathy-glib/account-manager.c +++ b/telepathy-glib/account-manager.c @@ -35,6 +35,7 @@ #define DEBUG_FLAG TP_DEBUG_ACCOUNTS #include "telepathy-glib/debug-internal.h" #include "telepathy-glib/proxy-internal.h" +#include "telepathy-glib/simple-client-factory-internal.h" #include "telepathy-glib/_gen/tp-cli-account-manager-body.h" @@ -681,6 +682,13 @@ tp_account_manager_init_known_interfaces (void) TpAccountManager * tp_account_manager_new (TpDBusDaemon *bus_daemon) { + return _tp_account_manager_new_with_factory (bus_daemon, NULL); +} + +TpAccountManager * +_tp_account_manager_new_with_factory (TpDBusDaemon *bus_daemon, + TpSimpleClientFactory *factory) +{ TpAccountManager *self; g_return_val_if_fail (TP_IS_DBUS_DAEMON (bus_daemon), NULL); @@ -690,6 +698,7 @@ tp_account_manager_new (TpDBusDaemon *bus_daemon) "dbus-connection", ((TpProxy *) bus_daemon)->dbus_connection, "bus-name", TP_ACCOUNT_MANAGER_BUS_NAME, "object-path", TP_ACCOUNT_MANAGER_OBJECT_PATH, + "factory", factory, NULL)); return self; diff --git a/telepathy-glib/account.c b/telepathy-glib/account.c index b097e1e..eb183f6 100644 --- a/telepathy-glib/account.c +++ b/telepathy-glib/account.c @@ -36,6 +36,7 @@ #include "telepathy-glib/connection-internal.h" #include "telepathy-glib/debug-internal.h" #include "telepathy-glib/proxy-internal.h" +#include "telepathy-glib/simple-client-factory-internal.h" #include #include "telepathy-glib/_gen/signals-marshal.h" @@ -1838,6 +1839,15 @@ tp_account_new (TpDBusDaemon *bus_daemon, const gchar *object_path, GError **error) { + return _tp_account_new_with_factory (bus_daemon, object_path, error, NULL); +} + +TpAccount * +_tp_account_new_with_factory (TpDBusDaemon *bus_daemon, + const gchar *object_path, + GError **error, + TpSimpleClientFactory *factory) +{ TpAccount *self; g_return_val_if_fail (TP_IS_DBUS_DAEMON (bus_daemon), NULL); @@ -1852,6 +1862,7 @@ tp_account_new (TpDBusDaemon *bus_daemon, "dbus-connection", ((TpProxy *) bus_daemon)->dbus_connection, "bus-name", TP_ACCOUNT_MANAGER_BUS_NAME, "object-path", object_path, + "factory", factory, NULL)); return self; diff --git a/telepathy-glib/channel.c b/telepathy-glib/channel.c index a42cd45..338323d 100644 --- a/telepathy-glib/channel.c +++ b/telepathy-glib/channel.c @@ -32,6 +32,7 @@ #define DEBUG_FLAG TP_DEBUG_CHANNEL #include "telepathy-glib/debug-internal.h" #include "telepathy-glib/proxy-internal.h" +#include "telepathy-glib/simple-client-factory-internal.h" #include "telepathy-glib/_gen/signals-marshal.h" #include "_gen/tp-cli-channel-body.h" @@ -1787,6 +1788,17 @@ tp_channel_new_from_properties (TpConnection *conn, const GHashTable *immutable_properties, GError **error) { + return _tp_channel_new_with_factory (conn, object_path, immutable_properties, + error, NULL); +} + +TpChannel * +_tp_channel_new_with_factory (TpConnection *conn, + const gchar *object_path, + const GHashTable *immutable_properties, + GError **error, + TpSimpleClientFactory *factory) +{ TpProxy *conn_proxy = (TpProxy *) conn; TpChannel *ret = NULL; @@ -1809,6 +1821,7 @@ tp_channel_new_from_properties (TpConnection *conn, "object-path", object_path, "handle-type", (guint) TP_UNKNOWN_HANDLE_TYPE, "channel-properties", immutable_properties, + "factory", factory, NULL)); finally: diff --git a/telepathy-glib/connection.c b/telepathy-glib/connection.c index dd49ed3..c157e5a 100644 --- a/telepathy-glib/connection.c +++ b/telepathy-glib/connection.c @@ -42,6 +42,7 @@ #include "telepathy-glib/dbus-internal.h" #include "telepathy-glib/debug-internal.h" #include "telepathy-glib/proxy-internal.h" +#include "telepathy-glib/simple-client-factory-internal.h" #include "telepathy-glib/util-internal.h" #include "telepathy-glib/_gen/signals-marshal.h" @@ -1786,6 +1787,17 @@ tp_connection_new (TpDBusDaemon *dbus, const gchar *object_path, GError **error) { + return _tp_connection_new_with_factory (dbus, bus_name, object_path, error, + NULL); +} + +TpConnection * +_tp_connection_new_with_factory (TpDBusDaemon *dbus, + const gchar *bus_name, + const gchar *object_path, + GError **error, + TpSimpleClientFactory *factory) +{ gchar *dup_path = NULL; gchar *dup_name = NULL; gchar *dup_unique_name = NULL; @@ -1831,6 +1843,7 @@ tp_connection_new (TpDBusDaemon *dbus, "dbus-daemon", dbus, "bus-name", bus_name, "object-path", object_path, + "factory", factory, NULL)); finally: diff --git a/telepathy-glib/introspection.am b/telepathy-glib/introspection.am index 0f96114..1bb9a5c 100644 --- a/telepathy-glib/introspection.am +++ b/telepathy-glib/introspection.am @@ -36,6 +36,7 @@ INTROSPECTION_FILES = \ $(srcdir)/debug.c $(srcdir)/debug.h \ $(srcdir)/base-client.c $(srcdir)/base-client.h \ $(srcdir)/simple-approver.c $(srcdir)/simple-approver.h \ + $(srcdir)/simple-client-factory.c $(srcdir)/simple-client-factory.h \ $(srcdir)/simple-handler.c $(srcdir)/simple-handler.h \ $(srcdir)/simple-observer.c $(srcdir)/simple-observer.h \ $(srcdir)/dbus-properties-mixin.c $(srcdir)/dbus-properties-mixin.h \ diff --git a/telepathy-glib/proxy.c b/telepathy-glib/proxy.c index b64e919..ed6d94c 100644 --- a/telepathy-glib/proxy.c +++ b/telepathy-glib/proxy.c @@ -24,7 +24,9 @@ #include -#include +#include +#include +#include #include "dbus-internal.h" #define DEBUG_FLAG TP_DEBUG_PROXY @@ -386,6 +388,8 @@ struct _TpProxyPrivate { guint pending_will_announce_calls; gboolean dispose_has_run; + + TpSimpleClientFactory *factory; }; G_DEFINE_TYPE (TpProxy, tp_proxy, G_TYPE_OBJECT) @@ -397,6 +401,7 @@ enum PROP_BUS_NAME, PROP_OBJECT_PATH, PROP_INTERFACES, + PROP_FACTORY, N_PROPS }; @@ -876,6 +881,9 @@ tp_proxy_get_property (GObject *object, g_value_take_boxed (value, g_ptr_array_free (strings, FALSE)); } break; + case PROP_FACTORY: + g_value_set_object (value, self->priv->factory); + break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); break; @@ -941,6 +949,10 @@ tp_proxy_set_property (GObject *object, g_assert (self->object_path == NULL); self->object_path = g_value_dup_string (value); break; + case PROP_FACTORY: + g_assert (self->priv->factory == NULL); + self->priv->factory = g_value_dup_object (value); + break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); break; @@ -1119,6 +1131,7 @@ tp_proxy_dispose (GObject *object) tp_proxy_invalidate (self, &e); tp_clear_object (&self->dbus_daemon); + tp_clear_object (&self->priv->factory); G_OBJECT_CLASS (tp_proxy_parent_class)->dispose (object); } @@ -1324,6 +1337,20 @@ tp_proxy_class_init (TpProxyClass *klass) param_spec); /** + * TpProxy:factory: + * + * The #TpSimpleClientFactory that have been used to create this proxy, + * or %NULL if proxy was not created through a factory. + */ + param_spec = g_param_spec_object ("factory", "Simple Client Factory", + "The TpSimpleClientFactory used to create this proxy", + TP_TYPE_SIMPLE_CLIENT_FACTORY, + G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE | G_PARAM_STATIC_NAME | + G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB); + g_object_class_install_property (object_class, PROP_FACTORY, + param_spec); + + /** * TpProxy::interface-added: (skip) * @self: the proxy object * @id: the GQuark representing the interface @@ -1366,6 +1393,26 @@ tp_proxy_class_init (TpProxyClass *klass) } /** + * tp_proxy_get_factory: + * @self: a #TpProxy or subclass + * + * + * + * Returns: (transfer none): the same value as #TpProxy:factory property + * + * Since: 0.UNRELEASED + */ +TpSimpleClientFactory * +tp_proxy_get_factory (gpointer self) +{ + TpProxy *proxy = self; + + g_return_val_if_fail (TP_IS_PROXY (self), NULL); + + return proxy->priv->factory; +} + +/** * tp_proxy_get_dbus_daemon: * @self: a #TpProxy or subclass * diff --git a/telepathy-glib/proxy.h b/telepathy-glib/proxy.h index 8b0cdfb..c170c4a 100644 --- a/telepathy-glib/proxy.h +++ b/telepathy-glib/proxy.h @@ -32,6 +32,8 @@ G_BEGIN_DECLS /* Forward declaration of a subclass - from dbus.h */ typedef struct _TpDBusDaemon TpDBusDaemon; +/* Forward declaration - from simple-client-factory.h */ +typedef struct _TpSimpleClientFactory TpSimpleClientFactory; typedef struct _TpProxyPrivate TpProxyPrivate; @@ -154,6 +156,8 @@ GType tp_proxy_get_type (void); gboolean tp_proxy_has_interface_by_id (gpointer self, GQuark iface); gboolean tp_proxy_has_interface (gpointer self, const gchar *iface); +TpSimpleClientFactory *tp_proxy_get_factory (gpointer self); + TpDBusDaemon *tp_proxy_get_dbus_daemon (gpointer self); DBusGConnection *tp_proxy_get_dbus_connection (gpointer self); diff --git a/telepathy-glib/simple-client-factory-internal.h b/telepathy-glib/simple-client-factory-internal.h new file mode 100644 index 0000000..cb7c974 --- /dev/null +++ b/telepathy-glib/simple-client-factory-internal.h @@ -0,0 +1,44 @@ +/* + * Simple client factory internal + * + * Copyright © 2011 Collabora Ltd. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef __TP_SIMPLE_CLIENT_FACTORY_INTERNAL_H__ +#define __TP_SIMPLE_CLIENT_FACTORY_INTERNAL_H__ + +#include + +G_BEGIN_DECLS + +TpAccountManager *_tp_account_manager_new_with_factory (TpDBusDaemon *bus_daemon, + TpSimpleClientFactory *factory); + +TpAccount *_tp_account_new_with_factory (TpDBusDaemon *bus_daemon, + const gchar *object_path, GError **error, TpSimpleClientFactory *factory); + +TpConnection *_tp_connection_new_with_factory (TpDBusDaemon *dbus, + const gchar *bus_name, const gchar *object_path, GError **error, + TpSimpleClientFactory *factory); + +TpChannel *_tp_channel_new_with_factory (TpConnection *conn, + const gchar *object_path, const GHashTable *immutable_properties, + GError **error, TpSimpleClientFactory *factory); + +G_END_DECLS + +#endif diff --git a/telepathy-glib/simple-client-factory.c b/telepathy-glib/simple-client-factory.c new file mode 100644 index 0000000..df5d216 --- /dev/null +++ b/telepathy-glib/simple-client-factory.c @@ -0,0 +1,848 @@ +/* + * Simple client factory + * + * Copyright © 2011 Collabora Ltd. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** + * SECTION:simple-client-factory + * @title: TpSimpleClientFactory + * @short_description: simple client factory + * @see_also: #TpAutomaticClientFactory + * + * This factory constructs various #TpProxy subclasses like #TpDBusDaemon, + * #TpAccountManager, #TpAccount, #TpConnection and #TpChannel. It guarantees + * per-factory uniqueness of those objects. It is also used to describe the + * features desired for each of those object classes. + * + * For example when a #TpAccount object created using this factory needs to + * construct its #TpConnection, it will ensure that all desired features are + * prepared. + * + * Since: 0.UNRELEASED + */ + +/** + * TpSimpleClientFactory: + * + * Data structure representing a #TpSimpleClientFactory + * + * Since: 0.UNRELEASED + */ + +/** + * TpSimpleClientFactoryClass: + * @parent_class: the parent class + * + * The class of a #TpSimpleClientFactory. + * + * Since: 0.UNRELEASED + */ + +/** + * TpSimpleClientFactoryClass: + * @parent_class: the parent + * @create_account_manager: virtual method used to create a #TpAccountManager; + * see tp_simple_client_factory_dup_account_manager() + * @create_account: virtual method used to create a #TpAccount; + * see tp_simple_client_factory_dup_account() + * @dup_account_features: virtual method returning account features that + * have to be prepared on newly created accounts; + * see tp_simple_client_factory_dup_account_features() + * @create_connection: virtual method used to create a #TpConnection; + * see tp_simple_client_factory_dup_connection() + * @dup_connection_features: virtual method returning connection features that + * have to be prepared on newly created connections; + * see tp_simple_client_factory_dup_connection_features() + * @create_channel: virtual method used to create a #TpChannel; + * see tp_simple_client_factory_dup_channel() + * @dup_channel_features: virtual method returning connection features that + * have to be prepared on newly created channel; + * see tp_simple_client_factory_dup_channel_features() + * @create_contact: virtual method used to create a #TpContact; + * see tp_simple_client_factory_dup_contact() + * @dup_contact_features: virtual method returning contact features that + * have to be prepared on newly created contacts; + * see tp_simple_client_factory_dup_contact_features() + * + * V-Table for #TpSimpleClientFactory sub-classing + * + * Since: 0.UNRELEASED + */ + +#include "telepathy-glib/simple-client-factory.h" + +#include + +#define DEBUG_FLAG TP_DEBUG_CLIENT +#include "telepathy-glib/connection-internal.h" +#include "telepathy-glib/contact-internal.h" +#include "telepathy-glib/debug-internal.h" +#include "telepathy-glib/simple-client-factory-internal.h" +#include "telepathy-glib/util-internal.h" + +struct _TpSimpleClientFactoryPrivate +{ + TpDBusDaemon *dbus; + GHashTable *proxy_cache; + GArray *desired_account_features; + GArray *desired_connection_features; + GArray *desired_channel_features; + GArray *desired_contact_features; +}; + +enum +{ + PROP_DBUS_DAEMON = 1, + N_PROPS +}; + +G_DEFINE_TYPE (TpSimpleClientFactory, tp_simple_client_factory, G_TYPE_OBJECT) + +static void +proxy_invalidated_cb (TpProxy *proxy, + guint domain, + gint code, + gchar *message, + TpSimpleClientFactory *self) +{ + g_hash_table_remove (self->priv->proxy_cache, + tp_proxy_get_object_path (proxy)); +} + +static void +insert_proxy (TpSimpleClientFactory *self, + gpointer proxy) +{ + if (proxy == NULL) + return; + + g_hash_table_insert (self->priv->proxy_cache, + (gpointer) tp_proxy_get_object_path (proxy), proxy); + tp_g_signal_connect_object (proxy, "invalidated", + G_CALLBACK (proxy_invalidated_cb), self, 0); +} + +static gpointer +lookup_proxy (TpSimpleClientFactory *self, + const gchar *object_path) +{ + return g_hash_table_lookup (self->priv->proxy_cache, object_path); +} + +static TpAccountManager * +create_account_manager_impl (TpSimpleClientFactory *self) +{ + return _tp_account_manager_new_with_factory (self->priv->dbus, self); +} + +static TpAccount * +create_account_impl (TpSimpleClientFactory *self, + const gchar *object_path, + GError **error) +{ + return _tp_account_new_with_factory (self->priv->dbus, object_path, error, + self); +} + +static GArray * +dup_account_features_impl (TpSimpleClientFactory *self, + TpAccount *account) +{ + return _tp_quark_array_copy ( + (GQuark *) self->priv->desired_account_features->data); +} + +static TpConnection * +create_connection_impl (TpSimpleClientFactory *self, + const gchar *object_path, + GError **error) +{ + return _tp_connection_new_with_factory (self->priv->dbus, NULL, object_path, + error, self); +} + +static GArray * +dup_connection_features_impl (TpSimpleClientFactory *self, + TpConnection *connection) +{ + return _tp_quark_array_copy ( + (GQuark *) self->priv->desired_connection_features->data); +} + +static TpChannel * +create_channel_impl (TpSimpleClientFactory *self, + TpConnection *conn, + const gchar *object_path, + const GHashTable *immutable_properties, + GError **error) +{ + return _tp_channel_new_with_factory (conn, object_path, immutable_properties, + error, self); +} + +static GArray * +dup_channel_features_impl (TpSimpleClientFactory *self, + TpChannel *channel) +{ + return _tp_quark_array_copy ( + (GQuark *) self->priv->desired_channel_features->data); +} + +static TpContact * +create_contact_impl (TpSimpleClientFactory *self, + TpConnection *connection, + TpHandle handle, + const gchar *identifier) +{ + return _tp_contact_new (connection, handle, identifier); +} + +static GArray * +dup_contact_features_impl (TpSimpleClientFactory *self, + TpConnection *connection) +{ + GArray *array; + + array = g_array_new (FALSE, FALSE, sizeof (TpContactFeature)); + g_array_append_vals (array, self->priv->desired_contact_features->data, + self->priv->desired_contact_features->len); + + return array; +} + +static void +tp_simple_client_factory_get_property (GObject *object, + guint property_id, + GValue *value, + GParamSpec *pspec) +{ + TpSimpleClientFactory *self = (TpSimpleClientFactory *) object; + + switch (property_id) + { + case PROP_DBUS_DAEMON: + g_value_set_object (value, self->priv->dbus); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + break; + } +} + +static void +tp_simple_client_factory_set_property (GObject *object, + guint property_id, + const GValue *value, + GParamSpec *pspec) +{ + TpSimpleClientFactory *self = (TpSimpleClientFactory *) object; + + switch (property_id) + { + case PROP_DBUS_DAEMON: + g_assert (self->priv->dbus == NULL); + self->priv->dbus = g_value_dup_object (value); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + break; + } +} + +static void +tp_simple_client_factory_constructed (GObject *object) +{ + TpSimpleClientFactory *self = (TpSimpleClientFactory *) object; + + g_assert (self->priv->dbus != NULL); + + G_OBJECT_CLASS (tp_simple_client_factory_parent_class)->constructed (object); +} + +static void +tp_simple_client_factory_finalize (GObject *object) +{ + TpSimpleClientFactory *self = (TpSimpleClientFactory *) object; + + g_clear_object (&self->priv->dbus); + tp_clear_pointer (&self->priv->proxy_cache, g_hash_table_unref); + tp_clear_pointer (&self->priv->desired_account_features, g_array_unref); + tp_clear_pointer (&self->priv->desired_connection_features, g_array_unref); + tp_clear_pointer (&self->priv->desired_channel_features, g_array_unref); + tp_clear_pointer (&self->priv->desired_contact_features, g_array_unref); + + G_OBJECT_CLASS (tp_simple_client_factory_parent_class)->finalize (object); +} + +static void +tp_simple_client_factory_init (TpSimpleClientFactory *self) +{ + GQuark feature; + TpContactFeature contact_feature; + + self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, TP_TYPE_SIMPLE_CLIENT_FACTORY, + TpSimpleClientFactoryPrivate); + + self->priv->proxy_cache = g_hash_table_new (g_str_hash, g_str_equal); + + self->priv->desired_account_features = g_array_new (TRUE, FALSE, + sizeof (GQuark)); + feature = TP_ACCOUNT_FEATURE_CORE; + g_array_append_val (self->priv->desired_account_features, feature); + + self->priv->desired_connection_features = g_array_new (TRUE, FALSE, + sizeof (GQuark)); + feature = TP_CONNECTION_FEATURE_CORE; + g_array_append_val (self->priv->desired_connection_features, feature); + + self->priv->desired_channel_features = g_array_new (TRUE, FALSE, + sizeof (GQuark)); + feature = TP_CHANNEL_FEATURE_CORE; + g_array_append_val (self->priv->desired_channel_features, feature); + + self->priv->desired_contact_features = g_array_new (FALSE, FALSE, + sizeof (TpContactFeature)); + contact_feature = TP_CONTACT_FEATURE_SUBSCRIPTION_STATES; + g_array_append_val (self->priv->desired_contact_features, contact_feature); +} + +static void +tp_simple_client_factory_class_init (TpSimpleClientFactoryClass *klass) +{ + GObjectClass *object_class = (GObjectClass *) klass; + GParamSpec *param_spec; + + g_type_class_add_private (klass, sizeof (TpSimpleClientFactoryPrivate)); + + object_class->get_property = tp_simple_client_factory_get_property; + object_class->set_property = tp_simple_client_factory_set_property; + object_class->constructed = tp_simple_client_factory_constructed; + object_class->finalize = tp_simple_client_factory_finalize; + + klass->create_account_manager = create_account_manager_impl; + klass->create_account = create_account_impl; + klass->dup_account_features = dup_account_features_impl; + klass->create_connection = create_connection_impl; + klass->dup_connection_features = dup_connection_features_impl; + klass->create_channel = create_channel_impl; + klass->dup_channel_features = dup_channel_features_impl; + klass->create_contact = create_contact_impl; + klass->dup_contact_features = dup_contact_features_impl; + + /** + * TpSimpleClientFactory:dbus-daemon: + * + * The D-Bus daemon for this object. + */ + param_spec = g_param_spec_object ("dbus-daemon", "D-Bus daemon", + "The D-Bus daemon used by this object", + TP_TYPE_DBUS_DAEMON, + G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE | G_PARAM_STATIC_NAME | + G_PARAM_STATIC_BLURB | G_PARAM_STATIC_NICK); + g_object_class_install_property (object_class, PROP_DBUS_DAEMON, + param_spec); +} + +/** + * tp_simple_client_factory_new: + * @dbus: a #TpDBusDaemon + * + * Convenient function to create a new #TpSimpleClientFactory instance. + * + * Returns: a new #TpSimpleClientFactory + * + * Since: 0.UNRELEASED + */ +TpSimpleClientFactory * +tp_simple_client_factory_new (TpDBusDaemon *dbus) +{ + return g_object_new (TP_TYPE_SIMPLE_CLIENT_FACTORY, + "dbus-daemon", dbus, + NULL); +} + +/** + * tp_simple_client_factory_get_dbus_daemon: + * @self: a #TpSimpleClientFactory object + * + * + * + * Returns: (transfer none): same value as #TpSimpleClientFactory:dbus-daemon + * property + * + * Since: 0.UNRELEASED + */ +TpDBusDaemon * +tp_simple_client_factory_get_dbus_daemon (TpSimpleClientFactory *self) +{ + g_return_val_if_fail (TP_IS_SIMPLE_CLIENT_FACTORY (self), NULL); + + return self->priv->dbus; +} + +/** + * tp_simple_client_factory_dup_account_manager: + * @self: a #TpSimpleClientFactory object + * + * If a #TpAccountManager proxy has already been created using this method, + * it will be returned. Otherwise a new one will be created. + * + * @self keeps only a weak-ref on the returned object, so it is the caller's + * responsability to keep a strong ref as long as needed. + * + * It is not guaranteed that any feature has been prepared on the proxy; + * caller is responsible to call tp_proxy_prepare_async() with the desired + * features. + * + * Returns: (transfer full): a new or existing #TpAccountManager proxy; + * see tp_account_manager_new(). + * + * Since: 0.UNRELEASED + */ +TpAccountManager * +tp_simple_client_factory_dup_account_manager (TpSimpleClientFactory *self) +{ + TpAccountManager *manager; + + g_return_val_if_fail (TP_IS_SIMPLE_CLIENT_FACTORY (self), NULL); + + manager = lookup_proxy (self, TP_ACCOUNT_MANAGER_OBJECT_PATH); + if (manager != NULL) + return g_object_ref (manager); + + manager = TP_SIMPLE_CLIENT_FACTORY_GET_CLASS (self)->create_account_manager (self); + insert_proxy (self, manager); + + return manager; +} + +/** + * tp_simple_client_factory_dup_account: + * @self: a #TpSimpleClientFactory object + * @object_path: the non-NULL object path of this account + * @error: Used to raise an error if @object_path is not valid + * + * If a #TpAccount proxy has already been created using this method for the + * given @object_path, it will be returned. Otherwise a new one will be created. + * + * @self keeps only a weak-ref on the returned object, so it is the caller's + * responsability to keep a strong ref as long as needed. + * + * It is not guaranteed that any feature has been prepared on the proxy; + * caller is responsible to call tp_proxy_prepare_async() with the desired + * features as given by tp_simple_client_factory_dup_account_features(). + * + * Returns: (transfer full): a new or existing #TpAccount proxy; + * see tp_account_manager_new(). + * + * Since: 0.UNRELEASED + */ +TpAccount * +tp_simple_client_factory_dup_account (TpSimpleClientFactory *self, + const gchar *object_path, + GError **error) +{ + TpAccount *account; + + g_return_val_if_fail (TP_IS_SIMPLE_CLIENT_FACTORY (self), NULL); + g_return_val_if_fail (g_variant_is_object_path (object_path), NULL); + + account = lookup_proxy (self, object_path); + if (account != NULL) + return g_object_ref (account); + + account = TP_SIMPLE_CLIENT_FACTORY_GET_CLASS (self)->create_account (self, + object_path, error); + insert_proxy (self, account); + + return account; +} + +/** + * tp_simple_client_factory_dup_account_features: + * @self: a #TpSimpleClientFactory object + * @account: a #TpAccount + * + * Return a zero terminated #GArray containing the #TpAccount features that + * should be prepared on @account. + * + * Returns: (transfer full) (element-type GLib.GQuark): a newly allocated + * #GArray + * + * Since: 0.UNRELEASED + */ +GArray * +tp_simple_client_factory_dup_account_features (TpSimpleClientFactory *self, + TpAccount *account) +{ + g_return_val_if_fail (TP_IS_SIMPLE_CLIENT_FACTORY (self), NULL); + g_return_val_if_fail (TP_IS_ACCOUNT (account), NULL); + g_return_val_if_fail (tp_proxy_get_factory (account) == self, NULL); + + return TP_SIMPLE_CLIENT_FACTORY_GET_CLASS (self)->dup_account_features (self, + account); +} + +/** + * tp_simple_client_factory_add_account_features: + * @self: a #TpSimpleClientFactory object + * @features: (transfer none) (array zero-terminated=1) (allow-none): an array + * of desired features, ending with 0; %NULL is equivalent to an array + * containing only 0 + * + * Add @features to the desired features to be prepared on #TpAccount + * objects. Those features will be added to the features already returned be + * tp_simple_client_factory_dup_account_features(). + * + * It is not necessary to add %TP_ACCOUNT_FEATURE_CORE as it is already + * included by default. + * + * Note that existing proxies won't be upgraded unless done manually using + * tp_proxy_prepare_async(). + * + * Since: 0.UNRELEASED + */ +void +tp_simple_client_factory_add_account_features ( + TpSimpleClientFactory *self, + GQuark *features) +{ + g_return_if_fail (TP_IS_SIMPLE_CLIENT_FACTORY (self)); + + _tp_quark_array_merge (self->priv->desired_account_features, features, -1); +} + +/** + * tp_simple_client_factory_dup_connection: + * @self: a #TpSimpleClientFactory object + * @object_path: the non-NULL object path of this connection + * @error: Used to raise an error if @object_path is not valid + * + * If a #TpConnection proxy has already been created using this method for the + * given @object_path, it will be returned. Otherwise a new one will be created. + * + * @self keeps only a weak-ref on the returned object, so it is the caller's + * responsability to keep a strong ref as long as needed. + * + * It is not guaranteed that any feature has been prepared on the proxy; + * caller is responsible to call tp_proxy_prepare_async() with the desired + * features as given by tp_simple_client_factory_dup_connection_features(). + * + * Returns: (transfer full): a new or existing #TpConnection proxy; + * see tp_connection_new(). + * + * Since: 0.UNRELEASED + */ +TpConnection * +tp_simple_client_factory_dup_connection (TpSimpleClientFactory *self, + const gchar *object_path, + GError **error) +{ + TpConnection *connection; + + g_return_val_if_fail (TP_IS_SIMPLE_CLIENT_FACTORY (self), NULL); + g_return_val_if_fail (g_variant_is_object_path (object_path), NULL); + + connection = lookup_proxy (self, object_path); + if (connection != NULL) + return g_object_ref (connection); + + connection = TP_SIMPLE_CLIENT_FACTORY_GET_CLASS (self)->create_connection (self, + object_path, error); + insert_proxy (self, connection); + + return connection; +} + +/** + * tp_simple_client_factory_dup_connection_features: + * @self: a #TpSimpleClientFactory object + * @connection: a #TpConnection + * + * Return a zero terminated #GArray containing the #TpConnection features that + * should be prepared on @connection. + * + * Returns: (transfer full) (element-type GLib.GQuark): a newly allocated + * #GArray + * + * Since: 0.UNRELEASED + */ +GArray * +tp_simple_client_factory_dup_connection_features (TpSimpleClientFactory *self, + TpConnection *connection) +{ + g_return_val_if_fail (TP_IS_SIMPLE_CLIENT_FACTORY (self), NULL); + g_return_val_if_fail (TP_IS_CONNECTION (connection), NULL); + g_return_val_if_fail (tp_proxy_get_factory (connection) == self, NULL); + + return TP_SIMPLE_CLIENT_FACTORY_GET_CLASS (self)->dup_connection_features ( + self, connection); +} + +/** + * tp_simple_client_factory_add_connection_features: + * @self: a #TpSimpleClientFactory object + * @features: (transfer none) (array zero-terminated=1) (allow-none): an array + * of desired features, ending with 0; %NULL is equivalent to an array + * containing only 0 + * + * Add @features to the desired features to be prepared on #TpConnection + * objects. Those features will be added to the features already returned be + * tp_simple_client_factory_dup_connection_features(). + * + * It is not necessary to add %TP_CONNECTION_FEATURE_CORE as it is already + * included by default. + * + * Note that existing proxies won't be upgraded unless done manually using + * tp_proxy_prepare_async(). + * + * Since: 0.UNRELEASED + */ +void +tp_simple_client_factory_add_connection_features ( + TpSimpleClientFactory *self, + GQuark *features) +{ + g_return_if_fail (TP_IS_SIMPLE_CLIENT_FACTORY (self)); + + _tp_quark_array_merge (self->priv->desired_connection_features, features, -1); +} + +/** + * tp_simple_client_factory_dup_channel: + * @self: a #TpSimpleClientFactory object + * @connection: a #TpConnection + * @object_path: the non-NULL object path of this connection + * @immutable_properties: (transfer none) (element-type utf8 GObject.Value): + * the immutable properties of the channel + * @error: Used to raise an error if @object_path is not valid + * + * If a #TpChannel proxy has already been created using this method for the + * given @object_path, it will be returned. Otherwise a new one will be created. + * + * @self keeps only a weak-ref on the returned object, so it is the caller's + * responsability to keep a strong ref as long as needed. + * + * It is not guaranteed that any feature has been prepared on the proxy; + * caller is responsible to call tp_proxy_prepare_async() with the desired + * features as given by tp_simple_client_factory_dup_channel_features(). + * + * Returns: (transfer full): a new or existing #TpChannel proxy; + * see tp_channel_new_with_properties(). + * + * Since: 0.UNRELEASED + */ +TpChannel * +tp_simple_client_factory_dup_channel (TpSimpleClientFactory *self, + TpConnection *connection, + const gchar *object_path, + const GHashTable *immutable_properties, + GError **error) +{ + TpChannel *channel; + + g_return_val_if_fail (TP_IS_SIMPLE_CLIENT_FACTORY (self), NULL); + g_return_val_if_fail (TP_IS_CONNECTION (connection), NULL); + g_return_val_if_fail (tp_proxy_get_factory (connection) == self, NULL); + g_return_val_if_fail (g_variant_is_object_path (object_path), NULL); + + channel = lookup_proxy (self, object_path); + if (channel != NULL) + return g_object_ref (channel); + + channel = TP_SIMPLE_CLIENT_FACTORY_GET_CLASS (self)->create_channel (self, + connection, object_path, immutable_properties, error); + insert_proxy (self, channel); + + return channel; +} + +/** + * tp_simple_client_factory_dup_channel_features: + * @self: a #TpSimpleClientFactory object + * @channel: a #TpChannel + * + * Return a zero terminated #GArray containing the #TpChannel features that + * should be prepared on @channel. + * + * Returns: (transfer full) (element-type GLib.GQuark): a newly allocated + * #GArray + * + * Since: 0.UNRELEASED + */ +GArray * +tp_simple_client_factory_dup_channel_features (TpSimpleClientFactory *self, + TpChannel *channel) +{ + g_return_val_if_fail (TP_IS_SIMPLE_CLIENT_FACTORY (self), NULL); + g_return_val_if_fail (TP_IS_CHANNEL (channel), NULL); + g_return_val_if_fail (tp_proxy_get_factory (channel) == self, NULL); + + return TP_SIMPLE_CLIENT_FACTORY_GET_CLASS (self)->dup_channel_features ( + self, channel); +} + +/** + * tp_simple_client_factory_add_channel_features: + * @self: a #TpSimpleClientFactory object + * @features: (transfer none) (array zero-terminated=1) (allow-none): an array + * of desired features, ending with 0; %NULL is equivalent to an array + * containing only 0 + * + * Add @features to the desired features to be prepared on #TpChannel + * objects. Those features will be added to the features already returned be + * tp_simple_client_factory_dup_channel_features(). + * + * It is not necessary to add %TP_CHANNEL_FEATURE_CORE as it is already + * included by default. + * + * Note that existing proxies won't be upgraded unless done manually using + * tp_proxy_prepare_async(). + * + * Since: 0.UNRELEASED + */ +void +tp_simple_client_factory_add_channel_features ( + TpSimpleClientFactory *self, + GQuark *features) +{ + g_return_if_fail (TP_IS_SIMPLE_CLIENT_FACTORY (self)); + + _tp_quark_array_merge (self->priv->desired_channel_features, features, -1); +} + +/** + * tp_simple_client_factory_dup_contact: + * @self: a #TpSimpleClientFactory object + * @connection: a #TpConnection + * @handle: a #TpHandle + * @identifier: a string representing the contact's identifier + * + * If a #TpContact has already been created using this method for the + * given @handle, it will be returned. Otherwise a new one will be created. + * + * @self keeps only a weak-ref on the returned object, so it is the caller's + * responsability to keep a strong ref as long as needed. + * + * For this to work properly @connection must have immortal handles. + * + * It is not guaranteed that any feature has been prepared on the contact; + * caller is responsible to call tp_connection_upgrade_contacts with the desired + * features as given by tp_simple_client_factory_dup_contact_features(). + * + * Returns: (transfer full): a new or existing #TpContact object. + * + * Since: 0.UNRELEASED + */ +TpContact * +tp_simple_client_factory_dup_contact (TpSimpleClientFactory *self, + TpConnection *connection, + TpHandle handle, + const gchar *identifier) +{ + TpContact *contact; + + g_return_val_if_fail (TP_IS_SIMPLE_CLIENT_FACTORY (self), NULL); + g_return_val_if_fail (TP_IS_CONNECTION (connection), NULL); + g_return_val_if_fail (tp_proxy_get_factory (connection) == self, NULL); + g_return_val_if_fail (tp_connection_has_immortal_handles (connection), NULL); + g_return_val_if_fail (handle != 0, NULL); + g_return_val_if_fail (identifier != NULL, NULL); + + contact = _tp_connection_lookup_contact (connection, handle); + if (contact != NULL) + return g_object_ref (contact); + + contact = TP_SIMPLE_CLIENT_FACTORY_GET_CLASS (self)->create_contact (self, + connection, handle, identifier); + + if (contact != NULL) + _tp_connection_add_contact (connection, handle, contact); + + return contact; +} + +/** + * tp_simple_client_factory_dup_contact_features: + * @self: a #TpSimpleClientFactory object + * @connection: a #TpConnection + * + * Return a #GArray containing the #TpContactFeature that should be prepared on + * all contacts of @connection. + * + * Returns: (transfer full) (element-type TelepathyGLib.ContactFeature): a newly + * allocated #GArray + * + * Since: 0.UNRELEASED + */ +GArray * +tp_simple_client_factory_dup_contact_features (TpSimpleClientFactory *self, + TpConnection *connection) +{ + g_return_val_if_fail (TP_IS_SIMPLE_CLIENT_FACTORY (self), NULL); + g_return_val_if_fail (TP_IS_CONNECTION (connection), NULL); + g_return_val_if_fail (tp_proxy_get_factory (connection) == self, NULL); + + return TP_SIMPLE_CLIENT_FACTORY_GET_CLASS (self)->dup_contact_features ( + self, connection); +} + +/** + * tp_simple_client_factory_add_contact_features: + * @self: a #TpSimpleClientFactory object + * @n_features: The number of features in @features (may be 0) + * @features: (array length=n_features) (allow-none): an array of desired + * features (may be %NULL if @n_features is 0) + * + * Add @features to the desired features to be prepared on #TpContact + * objects. Those features will be added to the features already returned be + * tp_simple_client_factory_dup_contact_features(). + * + * Note that existing contacts won't be upgraded unless done manually using + * tp_connection_upgrade_contacts(). + * + * Since: 0.UNRELEASED + */ +void +tp_simple_client_factory_add_contact_features (TpSimpleClientFactory *self, + guint n_features, const TpContactFeature *features) +{ + guint i; + + g_return_if_fail (TP_IS_SIMPLE_CLIENT_FACTORY (self)); + + /* Add features into desired_contact_features avoiding dups */ + for (i = 0; i < n_features; i++) + { + guint j; + gboolean found = FALSE; + + for (j = 0; j < self->priv->desired_contact_features->len; j++) + { + if (features[i] == g_array_index ( + self->priv->desired_contact_features, TpContactFeature, j)) + { + found = TRUE; + break; + } + } + + if (!found) + g_array_append_val (self->priv->desired_contact_features, features[i]); + } +} diff --git a/telepathy-glib/simple-client-factory.h b/telepathy-glib/simple-client-factory.h new file mode 100644 index 0000000..239fad8 --- /dev/null +++ b/telepathy-glib/simple-client-factory.h @@ -0,0 +1,141 @@ +/* + * Simple client factory + * + * Copyright © 2011 Collabora Ltd. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef __TP_SIMPLE_CLIENT_FACTORY_H__ +#define __TP_SIMPLE_CLIENT_FACTORY_H__ + +#include +#include +#include +#include +#include +#include + +G_BEGIN_DECLS + +/* TpSimpleClientFactory is typedef'd in proxy.h */ +typedef struct _TpSimpleClientFactoryPrivate TpSimpleClientFactoryPrivate; +typedef struct _TpSimpleClientFactoryClass TpSimpleClientFactoryClass; + +struct _TpSimpleClientFactoryClass { + /**/ + GObjectClass parent_class; + + /* TpAccountManager */ + TpAccountManager * (*create_account_manager) (TpSimpleClientFactory *self); + + /* TpAccount */ + TpAccount * (*create_account) (TpSimpleClientFactory *self, + const gchar *object_path, GError **error); + GArray * (*dup_account_features) (TpSimpleClientFactory *self, + TpAccount *account); + + /* TpConnection */ + TpConnection * (*create_connection) (TpSimpleClientFactory *self, + const gchar *object_path, GError **error); + GArray * (*dup_connection_features) (TpSimpleClientFactory *self, + TpConnection *connection); + + /* TpChannel */ + TpChannel * (*create_channel) (TpSimpleClientFactory *self, + TpConnection *conn, const gchar *object_path, + const GHashTable *immutable_properties, GError **error); + GArray * (*dup_channel_features) (TpSimpleClientFactory *self, + TpChannel *channel); + + /* TpContact */ + TpContact * (*create_contact) (TpSimpleClientFactory *self, + TpConnection *connection, TpHandle handle, const gchar *identifier); + GArray * (*dup_contact_features) (TpSimpleClientFactory *self, + TpConnection *connection); + + /**/ + GCallback padding[20]; +}; + +struct _TpSimpleClientFactory { + /**/ + GObject parent; + TpSimpleClientFactoryPrivate *priv; +}; + +GType tp_simple_client_factory_get_type (void); + +#define TP_TYPE_SIMPLE_CLIENT_FACTORY \ + (tp_simple_client_factory_get_type ()) +#define TP_SIMPLE_CLIENT_FACTORY(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), TP_TYPE_SIMPLE_CLIENT_FACTORY, \ + TpSimpleClientFactory)) +#define TP_SIMPLE_CLIENT_FACTORY_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), TP_TYPE_SIMPLE_CLIENT_FACTORY, \ + TpSimpleClientFactoryClass)) +#define TP_IS_SIMPLE_CLIENT_FACTORY(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TP_TYPE_SIMPLE_CLIENT_FACTORY)) +#define TP_IS_SIMPLE_CLIENT_FACTORY_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE ((klass), TP_TYPE_SIMPLE_CLIENT_FACTORY)) +#define TP_SIMPLE_CLIENT_FACTORY_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), TP_TYPE_SIMPLE_CLIENT_FACTORY, \ + TpSimpleClientFactoryClass)) + +TpSimpleClientFactory * tp_simple_client_factory_new (TpDBusDaemon *dbus); + +TpDBusDaemon *tp_simple_client_factory_get_dbus_daemon ( + TpSimpleClientFactory *self); + +/* TpAccountManager */ +TpAccountManager *tp_simple_client_factory_dup_account_manager ( + TpSimpleClientFactory *self); + +/* TpAccount */ +TpAccount *tp_simple_client_factory_dup_account (TpSimpleClientFactory *self, + const gchar *object_path, GError **error); +GArray * tp_simple_client_factory_dup_account_features ( + TpSimpleClientFactory *self, TpAccount *account); +void tp_simple_client_factory_add_account_features (TpSimpleClientFactory *self, + GQuark *features); + +/* TpConnection */ +TpConnection *tp_simple_client_factory_dup_connection ( + TpSimpleClientFactory *self, const gchar *object_path, GError **error); +GArray *tp_simple_client_factory_dup_connection_features ( + TpSimpleClientFactory *self, TpConnection *connection); +void tp_simple_client_factory_add_connection_features ( + TpSimpleClientFactory *self, GQuark *features); + +/* TpChannel */ +TpChannel *tp_simple_client_factory_dup_channel (TpSimpleClientFactory *self, + TpConnection *connection, const gchar *object_path, + const GHashTable *immutable_properties, GError **error); +GArray *tp_simple_client_factory_dup_channel_features ( + TpSimpleClientFactory *self, TpChannel *channel); +void tp_simple_client_factory_add_channel_features (TpSimpleClientFactory *self, + GQuark *features); + +/* TpContact */ +TpContact *tp_simple_client_factory_dup_contact (TpSimpleClientFactory *self, + TpConnection *connection, TpHandle handle, const gchar *identifier); +GArray *tp_simple_client_factory_dup_contact_features ( + TpSimpleClientFactory *self, TpConnection *connection); +void tp_simple_client_factory_add_contact_features (TpSimpleClientFactory *self, + guint n_features, const TpContactFeature *features); + +G_END_DECLS + +#endif diff --git a/telepathy-glib/telepathy-glib.h b/telepathy-glib/telepathy-glib.h index a1d50db..a7cbb17 100644 --- a/telepathy-glib/telepathy-glib.h +++ b/telepathy-glib/telepathy-glib.h @@ -56,6 +56,7 @@ #include #include #include +#include #include #include #include -- 1.7.4.1