#include <telepathy-glib/account-manager.h>
#include <telepathy-glib/util.h>
+#include <libempathy/empathy-client-factory.h>
#include <libempathy/empathy-tp-contact-factory.h>
#include <libempathy/empathy-contact-list.h>
#include <libempathy/empathy-contact-groups.h>
GtkSelectionData *selection)
{
EmpathyContactListViewPriv *priv;
- TpAccountManager *account_manager;
+ EmpathyClientFactory *factory;
TpConnection *connection = NULL;
TpAccount *account = NULL;
DndGetContactData *data;
return FALSE;
}
- account_manager = tp_account_manager_dup ();
+ factory = empathy_client_factory_dup ();
strv = g_strsplit (sel_data, ":", 2);
if (g_strv_length (strv) == 2) {
account_id = strv[0];
contact_id = strv[1];
- account = tp_account_manager_ensure_account (account_manager, account_id);
+ account = tp_simple_client_factory_ensure_account (
+ TP_SIMPLE_CLIENT_FACTORY (factory),
+ account_id, NULL, NULL);
}
if (account) {
connection = tp_account_get_connection (account);
DEBUG ("Failed to get connection for account '%s'", account_id);
g_free (new_group);
g_free (old_group);
- g_object_unref (account_manager);
+ g_object_unref (factory);
return FALSE;
}
data, (GDestroyNotify) contact_list_view_dnd_get_contact_free,
G_OBJECT (view));
g_strfreev (strv);
- g_object_unref (account_manager);
+ g_object_unref (factory);
return TRUE;
}
static void
log_window_create_observer (EmpathyLogWindow *self)
{
- TpDBusDaemon *dbus;
- GError *error = NULL;
+ TpAccountManager *am;
- dbus = tp_dbus_daemon_dup (&error);
+ am = tp_account_manager_dup ();
- if (dbus == NULL)
- {
- DEBUG ("Could not connect to the bus: %s", error->message);
- g_error_free (error);
- return;
- }
-
- self->priv->observer = tp_simple_observer_new (dbus, TRUE, "LogWindow",
+ self->priv->observer = tp_simple_observer_new_with_am (am, TRUE, "LogWindow",
TRUE, observe_channels,
g_object_ref (self), g_object_unref);
+
self->priv->channels = g_hash_table_new_full (g_direct_hash, g_direct_equal,
g_object_unref, g_object_unref);
tp_base_client_register (self->priv->observer, NULL);
- g_object_unref (dbus);
+ g_object_unref (am);
}
static TplEntity *
empathy-account-settings.h \
empathy-auth-factory.h \
empathy-camera-monitor.h \
- empathy-channel-factory.h \
empathy-chatroom-manager.h \
empathy-chatroom.h \
+ empathy-client-factory.h \
empathy-connection-managers.h \
empathy-connectivity.h \
empathy-contact-groups.h \
empathy-account-settings.c \
empathy-auth-factory.c \
empathy-camera-monitor.c \
- empathy-channel-factory.c \
empathy-chatroom-manager.c \
empathy-chatroom.c \
+ empathy-client-factory.c \
empathy-connection-managers.c \
empathy-connectivity.c \
empathy-contact-groups.c \
+++ /dev/null
-/*
- * Copyright (C) 2010 Collabora Ltd.
- *
- * 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., 51 Franklin St, Fifth Floor,
- * Boston, MA 02110-1301 USA
- *
- * Authors: Guillaume Desmottes <guillaume.desmottes@collabora.co.uk>
- */
-
-#include <config.h>
-
-#include "empathy-channel-factory.h"
-
-#include "empathy-tp-chat.h"
-#include "empathy-utils.h"
-
-#include <telepathy-glib/telepathy-glib.h>
-
-#include <telepathy-yell/telepathy-yell.h>
-
-static void factory_iface_init (gpointer, gpointer);
-
-G_DEFINE_TYPE_WITH_CODE (EmpathyChannelFactory, empathy_channel_factory,
- G_TYPE_OBJECT,
- G_IMPLEMENT_INTERFACE (TP_TYPE_CLIENT_CHANNEL_FACTORY, factory_iface_init))
-
-struct _EmpathyChannelFactoryPrivate
-{
- TpClientChannelFactory *automatic_factory;
-};
-
-static void
-empathy_channel_factory_dispose (GObject *object)
-{
- EmpathyChannelFactory *self = EMPATHY_CHANNEL_FACTORY (object);
- void (*dispose) (GObject *) =
- G_OBJECT_CLASS (empathy_channel_factory_parent_class)->dispose;
-
- tp_clear_object (&self->priv->automatic_factory);
-
- if (dispose != NULL)
- dispose (object);
-}
-
-static void
-empathy_channel_factory_class_init (EmpathyChannelFactoryClass *cls)
-{
- GObjectClass *object_class = G_OBJECT_CLASS (cls);
-
- g_type_class_add_private (cls, sizeof (EmpathyChannelFactoryPrivate));
-
- object_class->dispose = empathy_channel_factory_dispose;
-}
-
-static void
-empathy_channel_factory_init (EmpathyChannelFactory *self)
-{
- self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
- EMPATHY_TYPE_CHANNEL_FACTORY, EmpathyChannelFactoryPrivate);
-
- self->priv->automatic_factory = TP_CLIENT_CHANNEL_FACTORY (
- tp_automatic_proxy_factory_dup ());
-}
-
-EmpathyChannelFactory *
-empathy_channel_factory_new (void)
-{
- return g_object_new (EMPATHY_TYPE_CHANNEL_FACTORY,
- NULL);
-}
-
-EmpathyChannelFactory *
-empathy_channel_factory_dup (void)
-{
- static EmpathyChannelFactory *singleton = NULL;
-
- if (singleton != NULL)
- return g_object_ref (singleton);
-
- singleton = empathy_channel_factory_new ();
-
- g_object_add_weak_pointer (G_OBJECT (singleton), (gpointer) &singleton);
-
- return singleton;
-}
-
-static TpChannel *
-empathy_channel_factory_create_channel (
- TpClientChannelFactory *factory,
- TpConnection *conn,
- const gchar *path,
- GHashTable *properties,
- GError **error)
-{
- EmpathyChannelFactory *self = (EmpathyChannelFactory *) factory;
- const gchar *chan_type;
-
- chan_type = tp_asv_get_string (properties, TP_PROP_CHANNEL_CHANNEL_TYPE);
-
- if (!tp_strdiff (chan_type, TP_IFACE_CHANNEL_TYPE_TEXT))
- {
- TpAccount *account;
-
- account = empathy_get_account_for_connection (conn);
-
- return TP_CHANNEL (empathy_tp_chat_new (account, conn, path, properties));
- }
- else if (!tp_strdiff (chan_type, TPY_IFACE_CHANNEL_TYPE_CALL))
- {
- return TP_CHANNEL (tpy_call_channel_new (conn, path, properties,
- error));
- }
-
- return tp_client_channel_factory_create_channel (
- self->priv->automatic_factory, conn, path, properties, error);
-}
-
-static GArray *
-empathy_channel_factory_dup_channel_features (
- TpClientChannelFactory *factory,
- TpChannel *channel)
-{
- EmpathyChannelFactory *self = (EmpathyChannelFactory *) factory;
- GArray *features;
- GQuark feature;
-
- features = tp_client_channel_factory_dup_channel_features (
- self->priv->automatic_factory, channel);
-
- if (EMPATHY_IS_TP_CHAT (channel))
- {
- feature = TP_CHANNEL_FEATURE_CHAT_STATES;
- g_array_append_val (features, feature);
-
- feature = EMPATHY_TP_CHAT_FEATURE_READY;
- g_array_append_val (features, feature);
- }
-
- return features;
-}
-
-static void
-factory_iface_init (gpointer g_iface,
- gpointer unused G_GNUC_UNUSED)
-{
- TpClientChannelFactoryInterface *iface = g_iface;
-
- iface->obj_create_channel = empathy_channel_factory_create_channel;
- iface->obj_dup_channel_features =
- empathy_channel_factory_dup_channel_features;
-}
+++ /dev/null
-/*
- * Copyright (C) 2010 Collabora Ltd.
- *
- * 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., 51 Franklin St, Fifth Floor,
- * Boston, MA 02110-1301 USA
- *
- * Authors: Guillaume Desmottes <guillaume.desmottes@collabora.co.uk>
- */
-
-#ifndef __EMPATHY_CHANNEL_FACTORY_H__
-#define __EMPATHY_CHANNEL_FACTORY_H__
-
-#include <glib-object.h>
-
-G_BEGIN_DECLS
-
-#define EMPATHY_TYPE_CHANNEL_FACTORY (empathy_channel_factory_get_type ())
-#define EMPATHY_CHANNEL_FACTORY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), EMPATHY_TYPE_CHANNEL_FACTORY, EmpathyChannelFactory))
-#define EMPATHY_CHANNEL_FACTORY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), EMPATHY_TYPE_CHANNEL_FACTORY, EmpathyChannelFactoryClass))
-#define EMPATHY_IS_CHANNEL_FACTORY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), EMPATHY_TYPE_CHANNEL_FACTORY))
-#define EMPATHY_IS_CHANNEL_FACTORY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), EMPATHY_TYPE_CHANNEL_FACTORY))
-#define EMPATHY_CHANNEL_FACTORY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), EMPATHY_TYPE_CHANNEL_FACTORY, EmpathyChannelFactoryClass))
-
-typedef struct _EmpathyChannelFactory EmpathyChannelFactory;
-typedef struct _EmpathyChannelFactoryClass EmpathyChannelFactoryClass;
-typedef struct _EmpathyChannelFactoryPrivate EmpathyChannelFactoryPrivate;
-
-struct _EmpathyChannelFactory
-{
- GObject parent;
- EmpathyChannelFactoryPrivate *priv;
-};
-
-struct _EmpathyChannelFactoryClass
-{
- GObjectClass parent_class;
-};
-
-GType empathy_channel_factory_get_type (void) G_GNUC_CONST;
-
-EmpathyChannelFactory * empathy_channel_factory_new (void);
-
-EmpathyChannelFactory * empathy_channel_factory_dup (void);
-
-G_END_DECLS
-#endif /* __EMPATHY_CHANNEL_FACTORY_H__ */
#include <telepathy-glib/simple-observer.h>
#include <telepathy-glib/util.h>
+#include "empathy-client-factory.h"
#include "empathy-tp-chat.h"
#include "empathy-chatroom-manager.h"
-#include "empathy-channel-factory.h"
#include "empathy-utils.h"
#define DEBUG_FLAG EMPATHY_DEBUG_OTHER
gchar *account_id;
gboolean auto_connect;
gboolean always_urgent;
+ EmpathyClientFactory *factory;
+ GError *error = NULL;
priv = GET_PRIV (manager);
xmlFree (str);
}
- account = tp_account_manager_ensure_account (priv->account_manager,
- account_id);
+ factory = empathy_client_factory_dup ();
+
+ account = tp_simple_client_factory_ensure_account (
+ TP_SIMPLE_CLIENT_FACTORY (factory), account_id, NULL, &error);
+ g_object_unref (factory);
+
if (account == NULL)
{
+ DEBUG ("Failed to create account: %s", error->message);
+ g_error_free (error);
+
g_free (name);
g_free (room);
g_free (account_id);
EmpathyChatroomManager *self;
EmpathyChatroomManagerPriv *priv;
GError *error = NULL;
- TpDBusDaemon *dbus;
- EmpathyChannelFactory *factory;
if (chatroom_manager_singleton != NULL)
return g_object_ref (chatroom_manager_singleton);
g_free (dir);
}
- dbus = tp_dbus_daemon_dup (&error);
- if (dbus == NULL)
- {
- g_warning ("Failed to get TpDBusDaemon: %s", error->message);
-
- g_error_free (error);
- return obj;
- }
-
/* Setup a room observer */
- priv->observer = tp_simple_observer_new (dbus, TRUE,
+ priv->observer = tp_simple_observer_new_with_am (priv->account_manager, TRUE,
"Empathy.ChatroomManager", TRUE, observe_channels_cb, self, NULL);
- g_object_unref (dbus);
-
tp_base_client_take_observer_filter (priv->observer, tp_asv_new (
TP_PROP_CHANNEL_CHANNEL_TYPE, G_TYPE_STRING,
TP_IFACE_CHANNEL_TYPE_TEXT,
TP_HANDLE_TYPE_ROOM,
NULL));
- tp_base_client_add_connection_features_varargs (priv->observer,
- TP_CONNECTION_FEATURE_CAPABILITIES, NULL);
-
- factory = empathy_channel_factory_dup ();
-
- tp_base_client_set_channel_factory (priv->observer,
- TP_CLIENT_CHANNEL_FACTORY (factory));
-
if (!tp_base_client_register (priv->observer, &error))
{
g_critical ("Failed to register Observer: %s", error->message);
g_error_free (error);
}
- g_object_unref (factory);
return obj;
}
--- /dev/null
+/*
+ * Copyright (C) 2010 Collabora Ltd.
+ *
+ * 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., 51 Franklin St, Fifth Floor,
+ * Boston, MA 02110-1301 USA
+ *
+ * Authors: Guillaume Desmottes <guillaume.desmottes@collabora.co.uk>
+ */
+
+#include <config.h>
+
+#include "empathy-client-factory.h"
+
+#include "empathy-tp-chat.h"
+#include "empathy-utils.h"
+
+#include <telepathy-yell/telepathy-yell.h>
+
+G_DEFINE_TYPE (EmpathyClientFactory, empathy_client_factory,
+ TP_TYPE_AUTOMATIC_CLIENT_FACTORY)
+
+#define chainup ((TpSimpleClientFactoryClass *) \
+ empathy_client_factory_parent_class)
+
+/* FIXME: move to yell */
+static TpyCallChannel *
+call_channel_new_with_factory (TpSimpleClientFactory *factory,
+ TpConnection *conn,
+ const gchar *object_path,
+ const GHashTable *immutable_properties,
+ GError **error)
+{
+ TpProxy *conn_proxy = (TpProxy *) conn;
+
+ g_return_val_if_fail (TP_IS_CONNECTION (conn), NULL);
+ g_return_val_if_fail (object_path != NULL, NULL);
+ g_return_val_if_fail (immutable_properties != NULL, NULL);
+
+ if (!tp_dbus_check_valid_object_path (object_path, error))
+ return NULL;
+
+ return g_object_new (TPY_TYPE_CALL_CHANNEL,
+ "factory", factory,
+ "connection", conn,
+ "dbus-daemon", conn_proxy->dbus_daemon,
+ "bus-name", conn_proxy->bus_name,
+ "object-path", object_path,
+ "handle-type", (guint) TP_UNKNOWN_HANDLE_TYPE,
+ "channel-properties", immutable_properties,
+ NULL);
+}
+
+static TpChannel *
+empathy_client_factory_create_channel (TpSimpleClientFactory *factory,
+ TpConnection *conn,
+ const gchar *path,
+ const GHashTable *properties,
+ GError **error)
+{
+ const gchar *chan_type;
+
+ chan_type = tp_asv_get_string (properties, TP_PROP_CHANNEL_CHANNEL_TYPE);
+
+ if (!tp_strdiff (chan_type, TP_IFACE_CHANNEL_TYPE_TEXT))
+ {
+ TpAccount *account;
+
+ account = tp_connection_get_account (conn);
+
+ return TP_CHANNEL (empathy_tp_chat_new (
+ TP_SIMPLE_CLIENT_FACTORY (factory), account, conn, path,
+ properties));
+ }
+ else if (!tp_strdiff (chan_type, TPY_IFACE_CHANNEL_TYPE_CALL))
+ {
+ return TP_CHANNEL (call_channel_new_with_factory (
+ TP_SIMPLE_CLIENT_FACTORY (factory), conn, path, properties, error));
+ }
+
+ return chainup->create_channel (factory, conn, path, properties, error);
+}
+
+static GArray *
+empathy_client_factory_dup_channel_features (TpSimpleClientFactory *factory,
+ TpChannel *channel)
+{
+ GArray *features;
+ GQuark feature;
+
+ features = chainup->dup_channel_features (factory, channel);
+
+ if (EMPATHY_IS_TP_CHAT (channel))
+ {
+ feature = TP_CHANNEL_FEATURE_CHAT_STATES;
+ g_array_append_val (features, feature);
+
+ feature = EMPATHY_TP_CHAT_FEATURE_READY;
+ g_array_append_val (features, feature);
+ }
+
+ return features;
+}
+
+static GArray *
+empathy_client_factory_dup_connection_features (TpSimpleClientFactory *factory,
+ TpConnection *connection)
+{
+ GArray *features;
+ GQuark feature;
+
+ features = chainup->dup_connection_features (factory, connection);
+
+ feature = TP_CONNECTION_FEATURE_CAPABILITIES;
+ g_array_append_val (features, feature);
+
+ return features;
+}
+
+static void
+empathy_client_factory_class_init (EmpathyClientFactoryClass *cls)
+{
+ TpSimpleClientFactoryClass *simple_class = (TpSimpleClientFactoryClass *) cls;
+
+ simple_class->create_channel = empathy_client_factory_create_channel;
+ simple_class->dup_channel_features =
+ empathy_client_factory_dup_channel_features;
+
+ simple_class->dup_connection_features =
+ empathy_client_factory_dup_connection_features;
+}
+
+static void
+empathy_client_factory_init (EmpathyClientFactory *self)
+{
+}
+
+static EmpathyClientFactory *
+empathy_client_factory_new (TpDBusDaemon *dbus)
+{
+ return g_object_new (EMPATHY_TYPE_CLIENT_FACTORY,
+ "dbus-daemon", dbus,
+ NULL);
+}
+
+EmpathyClientFactory *
+empathy_client_factory_dup (void)
+{
+ static EmpathyClientFactory *singleton = NULL;
+ TpDBusDaemon *dbus;
+ GError *error = NULL;
+
+ if (singleton != NULL)
+ return g_object_ref (singleton);
+
+ dbus = tp_dbus_daemon_dup (&error);
+ if (dbus == NULL)
+ {
+ g_warning ("Failed to get TpDBusDaemon: %s", error->message);
+ g_error_free (error);
+ return NULL;
+ }
+
+ singleton = empathy_client_factory_new (dbus);
+ g_object_unref (dbus);
+
+ g_object_add_weak_pointer (G_OBJECT (singleton), (gpointer) &singleton);
+
+ return singleton;
+}
--- /dev/null
+/*
+ * Copyright (C) 2010 Collabora Ltd.
+ *
+ * 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., 51 Franklin St, Fifth Floor,
+ * Boston, MA 02110-1301 USA
+ *
+ * Authors: Guillaume Desmottes <guillaume.desmottes@collabora.co.uk>
+ */
+
+#ifndef __EMPATHY_CLIENT_FACTORY_H__
+#define __EMPATHY_CLIENT_FACTORY_H__
+
+#include <telepathy-glib/telepathy-glib.h>
+
+G_BEGIN_DECLS
+
+#define EMPATHY_TYPE_CLIENT_FACTORY (empathy_client_factory_get_type ())
+#define EMPATHY_CLIENT_FACTORY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), EMPATHY_TYPE_CLIENT_FACTORY, EmpathyClientFactory))
+#define EMPATHY_CLIENT_FACTORY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), EMPATHY_TYPE_CLIENT_FACTORY, EmpathyClientFactoryClass))
+#define EMPATHY_IS_CLIENT_FACTORY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), EMPATHY_TYPE_CLIENT_FACTORY))
+#define EMPATHY_IS_CLIENT_FACTORY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), EMPATHY_TYPE_CLIENT_FACTORY))
+#define EMPATHY_CLIENT_FACTORY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), EMPATHY_TYPE_CLIENT_FACTORY, EmpathyClientFactoryClass))
+
+typedef struct _EmpathyClientFactory EmpathyClientFactory;
+typedef struct _EmpathyClientFactoryClass EmpathyClientFactoryClass;
+typedef struct _EmpathyClientFactoryPrivate EmpathyClientFactoryPrivate;
+
+struct _EmpathyClientFactory
+{
+ TpAutomaticClientFactory parent;
+ EmpathyClientFactoryPrivate *priv;
+};
+
+struct _EmpathyClientFactoryClass
+{
+ TpAutomaticClientFactoryClass parent_class;
+};
+
+GType empathy_client_factory_get_type (void) G_GNUC_CONST;
+
+EmpathyClientFactory * empathy_client_factory_dup (void);
+
+G_END_DECLS
+#endif /* __EMPATHY_CLIENT_FACTORY_H__ */
/* FIXME: This assume the account manager already exists */
connection = tp_contact_get_connection (priv->tp_contact);
priv->account =
- g_object_ref (empathy_get_account_for_connection (connection));
+ g_object_ref (tp_connection_get_account (connection));
}
return priv->account;
{
EmpathyFTFactoryPriv *priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
EMPATHY_TYPE_FT_FACTORY, EmpathyFTFactoryPriv);
- TpDBusDaemon *dbus;
- GError *error = NULL;
+ TpAccountManager *am;
self->priv = priv;
- dbus = tp_dbus_daemon_dup (&error);
- if (dbus == NULL)
- {
- g_warning ("Failed to get TpDBusDaemon: %s", error->message);
- g_error_free (error);
- return;
- }
+ am = tp_account_manager_dup ();
- priv->handler = tp_simple_handler_new (dbus, FALSE, FALSE,
+ priv->handler = tp_simple_handler_new_with_am (am, FALSE, FALSE,
EMPATHY_FT_BUS_NAME_SUFFIX, FALSE, handle_channels_cb, self, NULL);
tp_base_client_take_handler_filter (priv->handler, tp_asv_new (
TP_PROP_CHANNEL_REQUESTED, G_TYPE_BOOLEAN, FALSE,
NULL));
- g_object_unref (dbus);
+ g_object_unref (am);
}
static void
# include <telepathy-logger/call-event.h>
#endif
+#include "empathy-client-factory.h"
#include "empathy-message.h"
#include "empathy-utils.h"
#include "empathy-enum-types.h"
empathy_message_from_tpl_log_event (TplEvent *logevent)
{
EmpathyMessage *retval = NULL;
- TpAccountManager *acc_man = NULL;
+ EmpathyClientFactory *factory;
TpAccount *account = NULL;
TplEntity *receiver = NULL;
TplEntity *sender = NULL;
g_return_val_if_fail (TPL_IS_EVENT (logevent), NULL);
- acc_man = tp_account_manager_dup ();
+ factory = empathy_client_factory_dup ();
/* FIXME Currently Empathy shows in the log viewer only valid accounts, so it
* won't be selected any non-existing (ie removed) account.
* When #610455 will be fixed, calling tp_account_manager_ensure_account ()
* If the way EmpathyContact stores the avatar is changes, it might not be
* needed anymore any TpAccount passing and the following call will be
* useless */
- account = tp_account_manager_ensure_account (acc_man,
- tpl_event_get_account_path (logevent));
- g_object_unref (acc_man);
+ account = tp_simple_client_factory_ensure_account (
+ TP_SIMPLE_CLIENT_FACTORY (factory),
+ tpl_event_get_account_path (logevent), NULL, NULL);
+ g_object_unref (factory);
if (TPL_IS_TEXT_EVENT (logevent)) {
TplTextEvent *textevent = TPL_TEXT_EVENT (logevent);
}
EmpathyTpChat *
-empathy_tp_chat_new (TpAccount *account,
+empathy_tp_chat_new (
+ TpSimpleClientFactory *factory,
+ TpAccount *account,
TpConnection *conn,
const gchar *object_path,
const GHashTable *immutable_properties)
g_return_val_if_fail (immutable_properties != NULL, NULL);
return g_object_new (EMPATHY_TYPE_TP_CHAT,
+ "factory", factory,
"account", account,
"connection", conn,
"dbus-daemon", conn_proxy->dbus_daemon,
GType empathy_tp_chat_get_type (void) G_GNUC_CONST;
-EmpathyTpChat *empathy_tp_chat_new (TpAccount *account,
+EmpathyTpChat *empathy_tp_chat_new (
+ TpSimpleClientFactory *factory,
+ TpAccount *account,
TpConnection *connection,
const gchar *object_path,
const GHashTable *immutable_properties);
#include <telepathy-glib/dbus.h>
#include <telepathy-glib/util.h>
+#include "empathy-client-factory.h"
#include "empathy-utils.h"
#include "empathy-contact-manager.h"
#include "empathy-individual-manager.h"
empathy_init (void)
{
static gboolean initialized = FALSE;
+ TpAccountManager *am;
+ EmpathyClientFactory *factory;
if (initialized)
return;
emp_cli_init ();
initialized = TRUE;
+
+ factory = empathy_client_factory_dup ();
+ am = tp_account_manager_new_with_factory (TP_SIMPLE_CLIENT_FACTORY (factory));
+ tp_account_manager_set_default (am);
+
+ g_object_unref (factory);
+ g_object_unref (am);
}
gboolean
return service_name;
}
-/* Note: this function depends on the account manager having its core feature
- * prepared. */
-TpAccount *
-empathy_get_account_for_connection (TpConnection *connection)
-{
- TpAccountManager *manager;
- TpAccount *account = NULL;
- GList *accounts, *l;
-
- manager = tp_account_manager_dup ();
-
- accounts = tp_account_manager_get_valid_accounts (manager);
-
- for (l = accounts; l != NULL; l = l->next)
- {
- TpAccount *a = l->data;
-
- if (tp_account_get_connection (a) == connection)
- {
- account = a;
- break;
- }
- }
-
- g_list_free (accounts);
- g_object_unref (manager);
-
- return account;
-}
-
gboolean
empathy_account_manager_get_accounts_connected (gboolean *connecting)
{
#define EMPATHY_ARRAY_TYPE_OBJECT (empathy_type_dbus_ao ())
GType empathy_type_dbus_ao (void);
-TpAccount * empathy_get_account_for_connection (TpConnection *connection);
-
gboolean empathy_account_manager_get_accounts_connected (gboolean *connecting);
void empathy_connect_new_account (TpAccount *account,
#include <telepathy-yell/telepathy-yell.h>
-#include <libempathy/empathy-channel-factory.h>
#include <libempathy/empathy-request-util.h>
#include <libempathy/empathy-tp-contact-factory.h>
#include <libempathy/empathy-utils.h>
{
EmpathyCallFactoryPriv *priv = G_TYPE_INSTANCE_GET_PRIVATE (obj,
EMPATHY_TYPE_CALL_FACTORY, EmpathyCallFactoryPriv);
- TpDBusDaemon *dbus;
- EmpathyChannelFactory *factory;
- GError *error = NULL;
+ TpAccountManager *am;
obj->priv = priv;
- dbus = tp_dbus_daemon_dup (&error);
- if (dbus == NULL)
- {
- g_warning ("Failed to get TpDBusDaemon: %s", error->message);
- g_error_free (error);
- return;
- }
+ am = tp_account_manager_dup ();
- priv->handler = tp_simple_handler_new (dbus, FALSE, FALSE,
+ priv->handler = tp_simple_handler_new_with_am (am, FALSE, FALSE,
EMPATHY_CALL_BUS_NAME_SUFFIX, FALSE, handle_channels_cb, obj, NULL);
- factory = empathy_channel_factory_new ();
- tp_base_client_set_channel_factory (priv->handler,
- TP_CLIENT_CHANNEL_FACTORY (factory));
- g_object_unref (factory);
-
tp_base_client_take_handler_filter (priv->handler, tp_asv_new (
TP_PROP_CHANNEL_CHANNEL_TYPE, G_TYPE_STRING,
TPY_IFACE_CHANNEL_TYPE_CALL,
"org.freedesktop.Telepathy.Channel.Interface.MediaSignalling/video/h264",
NULL);
- g_object_unref (dbus);
+ g_object_unref (am);
}
static GObject *
#include <telepathy-farstream/telepathy-farstream.h>
-#include <libempathy/empathy-channel-factory.h>
#include <libempathy/empathy-utils.h>
#include <libempathy/empathy-tp-contact-factory.h>
gint64 timestamp)
{
EmpathyCallHandlerPriv *priv = GET_PRIV (handler);
- EmpathyChannelFactory *channel_factory;
TpAccountChannelRequest *req;
TpAccount *account;
GHashTable *request;
req = tp_account_channel_request_new (account, request, timestamp);
- channel_factory = empathy_channel_factory_dup ();
- tp_account_channel_request_set_channel_factory (req,
- TP_CLIENT_CHANNEL_FACTORY (channel_factory));
- g_object_unref (channel_factory);
-
tp_account_channel_request_create_and_handle_channel_async (req, NULL,
empathy_call_handler_request_cb, handler);
#include <libnotify/notification.h>
-#include <libempathy/empathy-channel-factory.h>
#include <libempathy/empathy-utils.h>
#include <libempathy-gtk/empathy-images.h>
{
EmpathyCallObserverPriv *priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
EMPATHY_TYPE_CALL_OBSERVER, EmpathyCallObserverPriv);
- TpDBusDaemon *dbus;
- EmpathyChannelFactory *factory;
+ TpAccountManager *am;
GError *error = NULL;
self->priv = priv;
self->priv->notify_mgr = empathy_notify_manager_dup_singleton ();
- dbus = tp_dbus_daemon_dup (&error);
- if (dbus == NULL)
- {
- DEBUG ("Failed to get TpDBusDaemon: %s", error->message);
- g_error_free (error);
- return;
- }
+ am = tp_account_manager_dup ();
- self->priv->observer = tp_simple_observer_new (dbus, TRUE,
+ self->priv->observer = tp_simple_observer_new_with_am (am, TRUE,
"Empathy.CallObserver", FALSE,
observe_channels, self, NULL);
- factory = empathy_channel_factory_dup ();
- tp_base_client_set_channel_factory (self->priv->observer,
- TP_CLIENT_CHANNEL_FACTORY (factory));
- g_object_unref (factory);
-
/* Observe Call and StreamedMedia channels */
tp_base_client_take_observer_filter (self->priv->observer,
tp_asv_new (
g_error_free (error);
}
- g_object_unref (dbus);
+ g_object_unref (am);
}
EmpathyCallObserver *
#include <telepathy-glib/telepathy-glib.h>
#include <telepathy-glib/proxy-subclass.h>
-#include <libempathy/empathy-channel-factory.h>
#include <libempathy/empathy-chatroom-manager.h>
#include <libempathy/empathy-request-util.h>
#include <libempathy/empathy-utils.h>
empathy_chat_manager_init (EmpathyChatManager *self)
{
EmpathyChatManagerPriv *priv = GET_PRIV (self);
- TpDBusDaemon *dbus;
+ TpAccountManager *am;
GError *error = NULL;
- EmpathyChannelFactory *factory;
priv->closed_queue = g_queue_new ();
priv->messages = g_hash_table_new_full (g_str_hash, g_str_equal,
g_free, (GDestroyNotify) g_hash_table_unref);
- dbus = tp_dbus_daemon_dup (&error);
- if (dbus == NULL)
- {
- g_critical ("Failed to get D-Bus daemon: %s", error->message);
- g_error_free (error);
- return;
- }
+ am = tp_account_manager_dup ();
priv->chatroom_mgr = empathy_chatroom_manager_dup_singleton (NULL);
/* Text channels handler */
- priv->handler = tp_simple_handler_new (dbus, FALSE, FALSE,
+ priv->handler = tp_simple_handler_new_with_am (am, FALSE, FALSE,
EMPATHY_CHAT_BUS_NAME_SUFFIX, FALSE, handle_channels, self, NULL);
- /* EmpathyTpChat relies on these features being prepared */
- tp_base_client_add_connection_features_varargs (priv->handler,
- TP_CONNECTION_FEATURE_CAPABILITIES, 0);
- tp_base_client_add_channel_features_varargs (priv->handler,
- TP_CHANNEL_FEATURE_CHAT_STATES, 0);
-
- g_object_unref (dbus);
+ g_object_unref (am);
tp_base_client_take_handler_filter (priv->handler, tp_asv_new (
TP_PROP_CHANNEL_CHANNEL_TYPE, G_TYPE_STRING, TP_IFACE_CHANNEL_TYPE_TEXT,
TP_PROP_CHANNEL_TARGET_HANDLE_TYPE, G_TYPE_UINT, TP_HANDLE_TYPE_NONE,
NULL));
- factory = empathy_channel_factory_dup ();
-
- tp_base_client_set_channel_factory (priv->handler,
- TP_CLIENT_CHANNEL_FACTORY (factory));
-
if (!tp_base_client_register (priv->handler, &error))
{
g_critical ("Failed to register text handler: %s", error->message);
g_error_free (error);
}
-
- g_object_unref (factory);
}
static void
#include <telepathy-glib/telepathy-glib.h>
+#include <libempathy/empathy-client-factory.h>
#include <libempathy/empathy-contact.h>
#include <libempathy/empathy-message.h>
#include <libempathy/empathy-chatroom-manager.h>
EmpathyChat *chat = NULL;
EmpathyChatWindow *old_window;
TpAccount *account = NULL;
- TpAccountManager *account_manager;
+ EmpathyClientFactory *factory;
const gchar *id;
gchar **strv;
const gchar *account_id;
id = (const gchar*) gtk_selection_data_get_data (selection);
- /* FIXME: Perhaps should be sure that the account manager is
- * prepared before calling _ensure_account on it. */
- account_manager = tp_account_manager_dup ();
+ factory = empathy_client_factory_dup ();
DEBUG ("DND contact from roster with id:'%s'", id);
account_id = strv[0];
contact_id = strv[1];
account =
- tp_account_manager_ensure_account (account_manager, account_id);
+ tp_simple_client_factory_ensure_account (
+ TP_SIMPLE_CLIENT_FACTORY (factory), account_id,
+ NULL, NULL);
+
+ g_object_unref (factory);
if (account != NULL)
chat = empathy_chat_window_find_chat (account, contact_id, FALSE);
}
g_strfreev (strv);
return;
}
- g_object_unref (account_manager);
g_strfreev (strv);
old_window = chat_window_find_chat (chat);
#include <telepathy-yell/telepathy-yell.h>
-#include <libempathy/empathy-channel-factory.h>
#include <libempathy/empathy-presence-manager.h>
#include <libempathy/empathy-tp-contact-factory.h>
#include <libempathy/empathy-contact-manager.h>
{
EmpathyEventManagerPriv *priv = G_TYPE_INSTANCE_GET_PRIVATE (manager,
EMPATHY_TYPE_EVENT_MANAGER, EmpathyEventManagerPriv);
- TpDBusDaemon *dbus;
GError *error = NULL;
- EmpathyChannelFactory *factory;
+ TpAccountManager *am;
manager->priv = priv;
g_signal_connect (priv->contact_manager, "members-changed",
G_CALLBACK (event_manager_members_changed_cb), manager);
- dbus = tp_dbus_daemon_dup (&error);
- if (dbus == NULL)
- {
- DEBUG ("Failed to get TpDBusDaemon: %s", error->message);
- g_error_free (error);
- return;
- }
+ am = tp_account_manager_dup ();
- priv->approver = tp_simple_approver_new (dbus, "Empathy.EventManager", FALSE,
- approve_channels, manager, NULL);
-
- /* EmpathyTpChat relies on this feature being prepared */
- tp_base_client_add_connection_features_varargs (priv->approver,
- TP_CONNECTION_FEATURE_CAPABILITIES, 0);
+ priv->approver = tp_simple_approver_new_with_am (am, "Empathy.EventManager",
+ FALSE, approve_channels, manager, NULL);
/* Private text channels */
tp_base_client_take_approver_filter (priv->approver,
* EmpathyTpChat and its users to not depend on the connection being
* prepared with capabilities. I chose the former, obviously. :-) */
- priv->auth_approver = tp_simple_approver_new (dbus,
+ priv->auth_approver = tp_simple_approver_new_with_am (am,
"Empathy.AuthEventManager", FALSE, approve_channels, manager,
NULL);
TP_IFACE_CHANNEL_INTERFACE_SASL_AUTHENTICATION,
NULL));
- factory = empathy_channel_factory_dup ();
-
- tp_base_client_set_channel_factory (priv->approver,
- TP_CLIENT_CHANNEL_FACTORY (factory));
-
if (!tp_base_client_register (priv->approver, &error))
{
DEBUG ("Failed to register Approver: %s", error->message);
g_error_free (error);
}
- g_object_unref (factory);
- g_object_unref (dbus);
+ g_object_unref (am);
}
EmpathyEventManager *
{
EmpathyStreamedMediaFactoryPriv *priv = G_TYPE_INSTANCE_GET_PRIVATE (obj,
EMPATHY_TYPE_STREAMED_MEDIA_FACTORY, EmpathyStreamedMediaFactoryPriv);
- TpDBusDaemon *dbus;
- GError *error = NULL;
+ TpAccountManager *am;
obj->priv = priv;
- dbus = tp_dbus_daemon_dup (&error);
- if (dbus == NULL)
- {
- g_warning ("Failed to get TpDBusDaemon: %s", error->message);
- g_error_free (error);
- return;
- }
+ am = tp_account_manager_dup ();
- priv->handler = tp_simple_handler_new (dbus, FALSE, FALSE,
+ priv->handler = tp_simple_handler_new_with_am (am, FALSE, FALSE,
EMPATHY_AV_BUS_NAME_SUFFIX, FALSE, handle_channels_cb, obj, NULL);
tp_base_client_take_handler_filter (priv->handler, tp_asv_new (
"org.freedesktop.Telepathy.Channel.Interface.MediaSignalling/video/h264",
NULL);
- g_object_unref (dbus);
+ g_object_unref (am);
}
static GObject *
{ "name1", "room1", TRUE, TRUE },
{ "name2", "room2", FALSE, TRUE }};
- account_manager = empathy_account_manager_dup_singleton ();
+ account_manager = tp_account_manager_dup ();
account = get_test_account ();
copy_xml_file (CHATROOM_SAMPLE, CHATROOM_FILE);
{ "name4", "room4", FALSE, FALSE }};
EmpathyChatroom *chatroom;
- account_manager = empathy_account_manager_dup_singleton ();
+ account_manager = tp_account_manager_dup ();
account = get_test_account ();
EmpathyChatroom *chatroom;
EmpathyAccountManager *account_mgr;
- account_mgr = empathy_account_manager_dup_singleton ();
+ account_mgr = tp_account_manager_dup ();
account = get_test_account ();
copy_xml_file (CHATROOM_SAMPLE, CHATROOM_FILE);
{ "name2", "room2", FALSE, FALSE }};
EmpathyChatroom *chatroom;
- account_manager = empathy_account_manager_dup_singleton ();
+ account_manager = tp_account_manager_dup ();
account = get_test_account ();
copy_xml_file (CHATROOM_SAMPLE, CHATROOM_FILE);
{ "name2", "room2", FALSE, TRUE }};
EmpathyChatroom *chatroom;
- account_manager = empathy_account_manager_dup_singleton ();
+ account_manager = tp_account_manager_dup ();
account = get_test_account ();
copy_xml_file (CHATROOM_SAMPLE, "foo.xml");
projects / empathy.git / commitdiff