diff options
Diffstat (limited to 'libempathy')
26 files changed, 518 insertions, 2888 deletions
diff --git a/libempathy/Makefile.am b/libempathy/Makefile.am index 1e7d01ca3..91fdf7ba1 100644 --- a/libempathy/Makefile.am +++ b/libempathy/Makefile.am @@ -27,8 +27,6 @@ noinst_LTLIBRARIES = libempathy.la libempathy_headers = \ empathy-account-settings.h \ - empathy-account.h \ - empathy-account-manager.h \ empathy-chatroom.h \ empathy-chatroom-manager.h \ empathy-call-factory.h \ @@ -70,9 +68,7 @@ libempathy_headers = \ libempathy_la_SOURCES = \ $(libempathy_headers) \ - empathy-account.c \ empathy-account-settings.c \ - empathy-account-manager.c \ empathy-chatroom.c \ empathy-chatroom-manager.c \ empathy-call-factory.c \ diff --git a/libempathy/empathy-account-manager.c b/libempathy/empathy-account-manager.c deleted file mode 100644 index c71439bd4..000000000 --- a/libempathy/empathy-account-manager.c +++ /dev/null @@ -1,1060 +0,0 @@ -/* - * Copyright (C) 2008 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 - * - * Authors: Cosimo Cecchi <cosimo.cecchi@collabora.co.uk> - * Sjoerd Simons <sjoerd.simons@collabora.co.uk> - */ - -#include "config.h" - -#include <telepathy-glib/util.h> -#include <telepathy-glib/account-manager.h> -#include <telepathy-glib/enums.h> -#include <telepathy-glib/defs.h> -#include <telepathy-glib/dbus.h> -#include <telepathy-glib/interfaces.h> - -#include "empathy-account-manager.h" -#include "empathy-marshal.h" -#include "empathy-utils.h" - -#define DEBUG_FLAG EMPATHY_DEBUG_ACCOUNT -#include <libempathy/empathy-debug.h> - -#define GET_PRIV(obj) EMPATHY_GET_PRIV (obj, EmpathyAccountManager) - -#define MC5_BUS_NAME "org.freedesktop.Telepathy.MissionControl5" - -typedef struct { - /* (owned) unique name -> (reffed) EmpathyAccount */ - GHashTable *accounts; - int connected; - int connecting; - gboolean dispose_run; - gboolean ready; - TpAccountManager *tp_manager; - TpDBusDaemon *dbus; - - /* global presence */ - EmpathyAccount *global_account; - - TpConnectionPresenceType global_presence; - gchar *global_status; - gchar *global_status_message; - - /* requested global presence, could be different - * from the actual global one. - */ - TpConnectionPresenceType requested_presence; - gchar *requested_status; - gchar *requested_status_message; - - GHashTable *create_results; -} EmpathyAccountManagerPriv; - -enum { - ACCOUNT_CREATED, - ACCOUNT_DELETED, - ACCOUNT_ENABLED, - ACCOUNT_DISABLED, - ACCOUNT_CHANGED, - ACCOUNT_CONNECTION_CHANGED, - GLOBAL_PRESENCE_CHANGED, - NEW_CONNECTION, - LAST_SIGNAL -}; - -enum { - PROP_READY = 1, -}; - -static guint signals[LAST_SIGNAL]; -static EmpathyAccountManager *manager_singleton = NULL; - -G_DEFINE_TYPE (EmpathyAccountManager, empathy_account_manager, G_TYPE_OBJECT); - -static void -emp_account_connection_cb (EmpathyAccount *account, - GParamSpec *spec, - gpointer manager) -{ - TpConnection *connection = empathy_account_get_connection (account); - - DEBUG ("Signalling connection %p of account %s", - connection, empathy_account_get_unique_name (account)); - - if (connection != NULL) - g_signal_emit (manager, signals[NEW_CONNECTION], 0, connection); -} - -static void -emp_account_enabled_cb (EmpathyAccount *account, - GParamSpec *spec, - gpointer manager) -{ - if (empathy_account_is_enabled (account)) - g_signal_emit (manager, signals[ACCOUNT_ENABLED], 0, account); - else - g_signal_emit (manager, signals[ACCOUNT_DISABLED], 0, account); -} - -static void -emp_account_status_changed_cb (EmpathyAccount *account, - TpConnectionStatus old, - TpConnectionStatus new, - TpConnectionStatusReason reason, - gpointer user_data) -{ - EmpathyAccountManager *manager = EMPATHY_ACCOUNT_MANAGER (user_data); - EmpathyAccountManagerPriv *priv = GET_PRIV (manager); - - switch (old) - { - case TP_CONNECTION_STATUS_CONNECTING: - priv->connecting--; - break; - case TP_CONNECTION_STATUS_CONNECTED: - priv->connected--; - break; - default: - break; - } - - switch (new) - { - case TP_CONNECTION_STATUS_CONNECTING: - priv->connecting++; - break; - case TP_CONNECTION_STATUS_CONNECTED: - priv->connected++; - break; - default: - break; - } - - g_signal_emit (manager, signals[ACCOUNT_CONNECTION_CHANGED], 0, - account, reason, new, old); -} - -static void -emp_account_manager_update_global_presence (EmpathyAccountManager *manager) -{ - EmpathyAccountManagerPriv *priv = GET_PRIV (manager); - TpConnectionPresenceType presence = TP_CONNECTION_PRESENCE_TYPE_OFFLINE; - EmpathyAccount *account = NULL; - GHashTableIter iter; - gpointer value; - - /* Make the global presence is equal to the presence of the account with the - * highest availability */ - - g_hash_table_iter_init (&iter, priv->accounts); - while (g_hash_table_iter_next (&iter, NULL, &value)) - { - EmpathyAccount *a = EMPATHY_ACCOUNT (value); - TpConnectionPresenceType p; - - g_object_get (a, "presence", &p, NULL); - - if (tp_connection_presence_type_cmp_availability (p, presence) > 0) - { - account = a; - presence = p; - } - } - - priv->global_account = account; - g_free (priv->global_status); - g_free (priv->global_status_message); - - if (account == NULL) - { - priv->global_presence = presence; - priv->global_status = NULL; - priv->global_status_message = NULL; - return; - } - - g_object_get (account, - "presence", &priv->global_presence, - "status", &priv->global_status, - "status-message", &priv->global_status_message, - NULL); - - DEBUG ("Updated global presence to: %s (%d) \"%s\"", - priv->global_status, priv->global_presence, priv->global_status_message); -} - -static void -emp_account_presence_changed_cb (EmpathyAccount *account, - TpConnectionPresenceType presence, - const gchar *status, - const gchar *status_message, - gpointer user_data) -{ - EmpathyAccountManager *manager = EMPATHY_ACCOUNT_MANAGER (user_data); - EmpathyAccountManagerPriv *priv = GET_PRIV (manager); - - if (tp_connection_presence_type_cmp_availability (presence, - priv->global_presence) > 0) - { - priv->global_account = account; - - priv->global_presence = presence; - - g_free (priv->global_status); - priv->global_status = g_strdup (status); - - g_free (priv->global_status_message); - priv->global_status_message = g_strdup (status_message); - - goto signal; - } - else if (priv->global_account == account) - { - emp_account_manager_update_global_presence (manager); - goto signal; - } - - return; -signal: - g_signal_emit (manager, signals[GLOBAL_PRESENCE_CHANGED], 0, - priv->global_presence, priv->global_status, priv->global_status_message); -} - -static void -emp_account_removed_cb (EmpathyAccount *account, gpointer user_data) -{ - EmpathyAccountManager *manager = EMPATHY_ACCOUNT_MANAGER (user_data); - EmpathyAccountManagerPriv *priv = GET_PRIV (manager); - - g_object_ref (account); - g_hash_table_remove (priv->accounts, - empathy_account_get_unique_name (account)); - - g_signal_emit (manager, signals[ACCOUNT_DELETED], 0, account); - g_object_unref (account); -} - -static void -empathy_account_manager_check_ready (EmpathyAccountManager *manager) -{ - EmpathyAccountManagerPriv *priv = GET_PRIV (manager); - GHashTableIter iter; - gpointer value; - - if (priv->ready) - return; - - g_hash_table_iter_init (&iter, priv->accounts); - while (g_hash_table_iter_next (&iter, NULL, &value)) - { - EmpathyAccount *account = EMPATHY_ACCOUNT (value); - gboolean ready; - - g_object_get (account, "ready", &ready, NULL); - - if (!ready) - return; - } - - /* Rerequest global presence on the initial set of accounts for cases where a - * global presence was requested before the manager was ready */ - if (priv->requested_presence != TP_CONNECTION_PRESENCE_TYPE_UNSET) - empathy_account_manager_request_global_presence (manager, - priv->requested_presence, - priv->requested_status, - priv->requested_status_message); - - priv->ready = TRUE; - g_object_notify (G_OBJECT (manager), "ready"); -} - -static void -account_manager_account_ready_cb (GObject *obj, - GParamSpec *spec, - gpointer user_data) -{ - EmpathyAccountManager *manager = EMPATHY_ACCOUNT_MANAGER (user_data); - EmpathyAccountManagerPriv *priv = GET_PRIV (manager); - EmpathyAccount *account = EMPATHY_ACCOUNT (obj); - GSimpleAsyncResult *result; - gboolean ready; - - g_object_get (account, "ready", &ready, NULL); - - if (!ready) - return; - - /* see if there's any pending callbacks for this account */ - result = g_hash_table_lookup (priv->create_results, account); - if (result != NULL) - { - g_simple_async_result_set_op_res_gpointer ( - G_SIMPLE_ASYNC_RESULT (result), account, NULL); - - g_simple_async_result_complete (result); - - g_hash_table_remove (priv->create_results, account); - g_object_unref (result); - } - - g_signal_emit (manager, signals[ACCOUNT_CREATED], 0, account); - - g_signal_connect (account, "notify::connection", - G_CALLBACK (emp_account_connection_cb), manager); - - g_signal_connect (account, "notify::enabled", - G_CALLBACK (emp_account_enabled_cb), manager); - - g_signal_connect (account, "status-changed", - G_CALLBACK (emp_account_status_changed_cb), manager); - - g_signal_connect (account, "presence-changed", - G_CALLBACK (emp_account_presence_changed_cb), manager); - - g_signal_connect (account, "removed", - G_CALLBACK (emp_account_removed_cb), manager); - - empathy_account_manager_check_ready (manager); -} - -EmpathyAccount * -empathy_account_manager_get_account (EmpathyAccountManager *manager, - const gchar *path) -{ - EmpathyAccountManagerPriv *priv = GET_PRIV (manager); - - return g_hash_table_lookup (priv->accounts, path); -} - -EmpathyAccount * -empathy_account_manager_ensure_account (EmpathyAccountManager *manager, - const gchar *path) -{ - EmpathyAccountManagerPriv *priv = GET_PRIV (manager); - EmpathyAccount *account; - - account = g_hash_table_lookup (priv->accounts, path); - if (account != NULL) - return account; - - account = empathy_account_new (priv->dbus, path); - g_hash_table_insert (priv->accounts, g_strdup (path), account); - - g_signal_connect (account, "notify::ready", - G_CALLBACK (account_manager_account_ready_cb), manager); - - return account; -} - - -static void -account_manager_ensure_all_accounts (EmpathyAccountManager *manager, - GPtrArray *accounts) -{ - guint i, missing_accounts; - GHashTableIter iter; - EmpathyAccountManagerPriv *priv = GET_PRIV (manager); - gpointer value; - EmpathyAccount *account; - gboolean found = FALSE; - const gchar *name; - - /* ensure all accounts coming from MC5 first */ - for (i = 0; i < accounts->len; i++) - { - name = g_ptr_array_index (accounts, i); - - account = empathy_account_manager_ensure_account (manager, name); - empathy_account_refresh_properties (account); - } - - missing_accounts = empathy_account_manager_get_count (manager) - - accounts->len; - - if (missing_accounts > 0) - { - /* look for accounts we have and the Tp AccountManager doesn't, - * and remove them from our cache. - */ - - DEBUG ("%d missing accounts", missing_accounts); - - g_hash_table_iter_init (&iter, priv->accounts); - - while (g_hash_table_iter_next (&iter, NULL, &value) && - missing_accounts > 0) - { - account = value; - - /* look for this account in the AccountManager provided array */ - for (i = 0; i < accounts->len; i++) - { - name = g_ptr_array_index (accounts, i); - - if (!tp_strdiff - (name, empathy_account_get_unique_name (account))) - { - found = TRUE; - break; - } - } - - if (!found) - { - DEBUG ("Account %s was not found, remove it from the cache", - empathy_account_get_unique_name (account)); - - g_object_ref (account); - g_hash_table_iter_remove (&iter); - g_signal_emit (manager, signals[ACCOUNT_DELETED], 0, account); - g_object_unref (account); - - missing_accounts--; - } - - found = FALSE; - } - } -} - -static void -account_manager_got_all_cb (TpProxy *proxy, - GHashTable *properties, - const GError *error, - gpointer user_data, - GObject *weak_object) -{ - EmpathyAccountManager *manager = EMPATHY_ACCOUNT_MANAGER (weak_object); - GPtrArray *accounts; - - if (error != NULL) - { - DEBUG ("Failed to get account manager properties: %s", error->message); - return; - } - - accounts = tp_asv_get_boxed (properties, "ValidAccounts", - EMPATHY_ARRAY_TYPE_OBJECT); - - if (accounts != NULL) - account_manager_ensure_all_accounts (manager, accounts); - - empathy_account_manager_check_ready (manager); -} - -static void -account_validity_changed_cb (TpAccountManager *proxy, - const gchar *path, - gboolean valid, - gpointer user_data, - GObject *weak_object) -{ - EmpathyAccountManager *manager = EMPATHY_ACCOUNT_MANAGER (weak_object); - - if (!valid) - return; - - empathy_account_manager_ensure_account (manager, path); -} - -static void -account_manager_start_mc5 (TpDBusDaemon *bus) -{ - TpProxy *mc5_proxy; - - /* trigger MC5 starting */ - mc5_proxy = g_object_new (TP_TYPE_PROXY, - "dbus-daemon", bus, - "dbus-connection", tp_proxy_get_dbus_connection (TP_PROXY (bus)), - "bus-name", MC5_BUS_NAME, - "object-path", "/", - NULL); - - tp_cli_dbus_peer_call_ping (mc5_proxy, -1, NULL, NULL, NULL, NULL); - - g_object_unref (mc5_proxy); -} - -static void -account_manager_name_owner_cb (TpDBusDaemon *proxy, - const gchar *name, - const gchar *new_owner, - gpointer user_data) -{ - EmpathyAccountManager *manager = EMPATHY_ACCOUNT_MANAGER (user_data); - EmpathyAccountManagerPriv *priv = GET_PRIV (manager); - - DEBUG ("Name owner changed for %s, new name: %s", name, new_owner); - - if (EMP_STR_EMPTY (new_owner)) - { - /* MC5 quit or crashed for some reason, let's start it again */ - account_manager_start_mc5 (priv->dbus); - - if (priv->tp_manager != NULL) - g_object_unref (priv->tp_manager); - - priv->tp_manager = NULL; - return; - } - - if (priv->tp_manager == NULL) - { - priv->tp_manager = tp_account_manager_new (priv->dbus); - - tp_cli_account_manager_connect_to_account_validity_changed ( - priv->tp_manager, - account_validity_changed_cb, - NULL, - NULL, - G_OBJECT (manager), - NULL); - - tp_cli_dbus_properties_call_get_all (priv->tp_manager, -1, - TP_IFACE_ACCOUNT_MANAGER, - account_manager_got_all_cb, - NULL, - NULL, - G_OBJECT (manager)); - } -} - -static void -empathy_account_manager_init (EmpathyAccountManager *manager) -{ - EmpathyAccountManagerPriv *priv; - - priv = G_TYPE_INSTANCE_GET_PRIVATE (manager, - EMPATHY_TYPE_ACCOUNT_MANAGER, EmpathyAccountManagerPriv); - - manager->priv = priv; - priv->connected = priv->connecting = 0; - priv->global_presence = TP_CONNECTION_PRESENCE_TYPE_UNSET; - - priv->accounts = g_hash_table_new_full (g_str_hash, g_str_equal, - g_free, (GDestroyNotify) g_object_unref); - - priv->create_results = g_hash_table_new (g_direct_hash, g_direct_equal); - - priv->dbus = tp_dbus_daemon_dup (NULL); - - tp_dbus_daemon_watch_name_owner (priv->dbus, - TP_ACCOUNT_MANAGER_BUS_NAME, - account_manager_name_owner_cb, - manager, - NULL); - - account_manager_start_mc5 (priv->dbus); -} - -static void -do_finalize (GObject *obj) -{ - EmpathyAccountManager *manager = EMPATHY_ACCOUNT_MANAGER (obj); - EmpathyAccountManagerPriv *priv = GET_PRIV (manager); - - g_hash_table_destroy (priv->create_results); - g_hash_table_destroy (priv->accounts); - - g_free (priv->global_status); - g_free (priv->global_status_message); - - g_free (priv->requested_status); - g_free (priv->requested_status_message); - - G_OBJECT_CLASS (empathy_account_manager_parent_class)->finalize (obj); -} - -static void -do_dispose (GObject *obj) -{ - EmpathyAccountManager *manager = EMPATHY_ACCOUNT_MANAGER (obj); - EmpathyAccountManagerPriv *priv = GET_PRIV (manager); - GHashTableIter iter; - GSimpleAsyncResult *result; - - if (priv->dispose_run) - return; - - priv->dispose_run = TRUE; - - /* the manager is being destroyed while there are account creation - * processes pending; this should not happen, but emit the callbacks - * with an error anyway. - */ - g_hash_table_iter_init (&iter, priv->create_results); - while (g_hash_table_iter_next (&iter, NULL, (gpointer *) &result)) - { - g_simple_async_result_set_error (result, G_IO_ERROR, - G_IO_ERROR_CANCELLED, "The account manager was disposed while " - "creating the account"); - g_simple_async_result_complete (result); - g_object_unref (result); - } - g_hash_table_remove_all (priv->create_results); - - if (priv->dbus != NULL) - { - tp_dbus_daemon_cancel_name_owner_watch (priv->dbus, - TP_ACCOUNT_MANAGER_BUS_NAME, account_manager_name_owner_cb, manager); - - g_object_unref (priv->dbus); - priv->dbus = NULL; - } - - G_OBJECT_CLASS (empathy_account_manager_parent_class)->dispose (obj); -} - -static GObject * -do_constructor (GType type, - guint n_construct_params, - GObjectConstructParam *construct_params) -{ - GObject *retval; - - if (!manager_singleton) - { - retval = G_OBJECT_CLASS - (empathy_account_manager_parent_class)->constructor (type, - n_construct_params, construct_params); - manager_singleton = EMPATHY_ACCOUNT_MANAGER (retval); - g_object_add_weak_pointer (retval, (gpointer) &manager_singleton); - } - else - { - retval = g_object_ref (manager_singleton); - } - - return retval; -} - -static void -do_get_property (GObject *object, - guint prop_id, - GValue *value, - GParamSpec *pspec) -{ - EmpathyAccountManager *manager = EMPATHY_ACCOUNT_MANAGER (object); - EmpathyAccountManagerPriv *priv = GET_PRIV (manager); - - switch (prop_id) - { - case PROP_READY: - g_value_set_boolean (value, priv->ready); - break; - default: - G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); - break; - } -} - -static void -empathy_account_manager_class_init (EmpathyAccountManagerClass *klass) -{ - GObjectClass *oclass = G_OBJECT_CLASS (klass); - - oclass->finalize = do_finalize; - oclass->dispose = do_dispose; - oclass->constructor = do_constructor; - oclass->get_property = do_get_property; - - g_object_class_install_property (oclass, PROP_READY, - g_param_spec_boolean ("ready", - "Ready", - "Whether the initial state dump from the account manager is finished", - FALSE, - G_PARAM_STATIC_STRINGS | G_PARAM_READABLE)); - - signals[ACCOUNT_CREATED] = - g_signal_new ("account-created", - G_TYPE_FROM_CLASS (klass), - G_SIGNAL_RUN_LAST, - 0, - NULL, NULL, - g_cclosure_marshal_VOID__OBJECT, - G_TYPE_NONE, - 1, EMPATHY_TYPE_ACCOUNT); - - signals[ACCOUNT_DELETED] = - g_signal_new ("account-deleted", - G_TYPE_FROM_CLASS (klass), - G_SIGNAL_RUN_LAST, - 0, - NULL, NULL, - g_cclosure_marshal_VOID__OBJECT, - G_TYPE_NONE, - 1, EMPATHY_TYPE_ACCOUNT); - - signals[ACCOUNT_ENABLED] = - g_signal_new ("account-enabled", - G_TYPE_FROM_CLASS (klass), - G_SIGNAL_RUN_LAST, - 0, - NULL, NULL, - g_cclosure_marshal_VOID__OBJECT, - G_TYPE_NONE, - 1, EMPATHY_TYPE_ACCOUNT); - - signals[ACCOUNT_DISABLED] = - g_signal_new ("account-disabled", - G_TYPE_FROM_CLASS (klass), - G_SIGNAL_RUN_LAST, - 0, - NULL, NULL, - g_cclosure_marshal_VOID__OBJECT, - G_TYPE_NONE, - 1, EMPATHY_TYPE_ACCOUNT); - - signals[ACCOUNT_CHANGED] = - g_signal_new ("account-changed", - G_TYPE_FROM_CLASS (klass), - G_SIGNAL_RUN_LAST, - 0, - NULL, NULL, - g_cclosure_marshal_VOID__OBJECT, - G_TYPE_NONE, - 1, EMPATHY_TYPE_ACCOUNT); - - signals[ACCOUNT_CONNECTION_CHANGED] = - g_signal_new ("account-connection-changed", - G_TYPE_FROM_CLASS (klass), - G_SIGNAL_RUN_LAST, - 0, - NULL, NULL, - _empathy_marshal_VOID__OBJECT_INT_UINT_UINT, - G_TYPE_NONE, - 4, EMPATHY_TYPE_ACCOUNT, - G_TYPE_INT, /* reason */ - G_TYPE_UINT, /* actual connection */ - G_TYPE_UINT); /* previous connection */ - - signals[GLOBAL_PRESENCE_CHANGED] = - g_signal_new ("global-presence-changed", - G_TYPE_FROM_CLASS (klass), - G_SIGNAL_RUN_LAST, - 0, - NULL, NULL, - _empathy_marshal_VOID__UINT_STRING_STRING, - G_TYPE_NONE, - 3, G_TYPE_UINT, /* Presence type */ - G_TYPE_STRING, /* status */ - G_TYPE_STRING); /* stauts message*/ - - signals[NEW_CONNECTION] = - g_signal_new ("new-connection", - G_TYPE_FROM_CLASS (klass), - G_SIGNAL_RUN_LAST, - 0, - NULL, NULL, - g_cclosure_marshal_VOID__OBJECT, - G_TYPE_NONE, - 1, TP_TYPE_CONNECTION); - - g_type_class_add_private (oclass, sizeof (EmpathyAccountManagerPriv)); -} - -/* public methods */ - -EmpathyAccountManager * -empathy_account_manager_dup_singleton (void) -{ - return g_object_new (EMPATHY_TYPE_ACCOUNT_MANAGER, NULL); -} - -gboolean -empathy_account_manager_is_ready (EmpathyAccountManager *manager) -{ - EmpathyAccountManagerPriv *priv = GET_PRIV (manager); - - return priv->ready; -} - -int -empathy_account_manager_get_connected_accounts (EmpathyAccountManager *manager) -{ - EmpathyAccountManagerPriv *priv; - - g_return_val_if_fail (EMPATHY_IS_ACCOUNT_MANAGER (manager), 0); - - priv = GET_PRIV (manager); - - return priv->connected; -} - -int -empathy_account_manager_get_connecting_accounts ( - EmpathyAccountManager *manager) -{ - EmpathyAccountManagerPriv *priv; - - g_return_val_if_fail (EMPATHY_IS_ACCOUNT_MANAGER (manager), 0); - - priv = GET_PRIV (manager); - - return priv->connecting; -} - -/** - * empathy_account_manager_get_count: - * @manager: a #EmpathyAccountManager - * - * Get the number of accounts. - * - * Returns: the number of accounts. - **/ -int -empathy_account_manager_get_count (EmpathyAccountManager *manager) -{ - EmpathyAccountManagerPriv *priv; - - g_return_val_if_fail (EMPATHY_IS_ACCOUNT_MANAGER (manager), 0); - - priv = GET_PRIV (manager); - - return g_hash_table_size (priv->accounts); -} - -EmpathyAccount * -empathy_account_manager_get_account_for_connection ( - EmpathyAccountManager *manager, - TpConnection *connection) -{ - EmpathyAccountManagerPriv *priv; - GHashTableIter iter; - gpointer value; - - g_return_val_if_fail (EMPATHY_IS_ACCOUNT_MANAGER (manager), 0); - - priv = GET_PRIV (manager); - - g_hash_table_iter_init (&iter, priv->accounts); - while (g_hash_table_iter_next (&iter, NULL, &value)) - { - EmpathyAccount *account = EMPATHY_ACCOUNT (value); - - if (connection == empathy_account_get_connection (account)) - return account; - } - - return NULL; -} - -GList * -empathy_account_manager_dup_accounts (EmpathyAccountManager *manager) -{ - EmpathyAccountManagerPriv *priv; - GList *ret; - - g_return_val_if_fail (EMPATHY_IS_ACCOUNT_MANAGER (manager), NULL); - - priv = GET_PRIV (manager); - - ret = g_hash_table_get_values (priv->accounts); - g_list_foreach (ret, (GFunc) g_object_ref, NULL); - - return ret; -} - -/** - * empathy_account_manager_dup_connections: - * @manager: a #EmpathyAccountManager - * - * Get a #GList of all ready #TpConnection. The list must be freed with - * g_list_free, and its elements must be unreffed. - * - * Returns: the list of connections - **/ -GList * -empathy_account_manager_dup_connections (EmpathyAccountManager *manager) -{ - EmpathyAccountManagerPriv *priv; - GHashTableIter iter; - gpointer value; - GList *ret = NULL; - - g_return_val_if_fail (EMPATHY_IS_ACCOUNT_MANAGER (manager), NULL); - - priv = GET_PRIV (manager); - - g_hash_table_iter_init (&iter, priv->accounts); - while (g_hash_table_iter_next (&iter, NULL, &value)) - { - EmpathyAccount *account = EMPATHY_ACCOUNT (value); - TpConnection *connection; - - connection = empathy_account_get_connection (account); - if (connection != NULL) - ret = g_list_prepend (ret, g_object_ref (connection)); - } - - return ret; -} - -void -empathy_account_manager_request_global_presence ( - EmpathyAccountManager *manager, - TpConnectionPresenceType type, - const gchar *status, - const gchar *message) -{ - EmpathyAccountManagerPriv *priv = GET_PRIV (manager); - GHashTableIter iter; - gpointer value; - - DEBUG ("request global presence, type: %d, status: %s, message: %s", - type, status, message); - - g_hash_table_iter_init (&iter, priv->accounts); - while (g_hash_table_iter_next (&iter, NULL, &value)) - { - EmpathyAccount *account = EMPATHY_ACCOUNT (value); - gboolean ready; - - g_object_get (account, "ready", &ready, NULL); - - if (ready) - empathy_account_request_presence (account, type, status, message); - } - - /* save the requested global presence, to use it in case we create - * new accounts or some accounts become ready. - */ - priv->requested_presence = type; - - if (tp_strdiff (priv->requested_status, status)) - { - g_free (priv->requested_status); - priv->requested_status = g_strdup (status); - } - - if (tp_strdiff (priv->requested_status_message, message)) - { - g_free (priv->requested_status_message); - priv->requested_status_message = g_strdup (message); - } -} - -TpConnectionPresenceType -empathy_account_manager_get_requested_global_presence ( - EmpathyAccountManager *manager, - gchar **status, - gchar **message) -{ - EmpathyAccountManagerPriv *priv = GET_PRIV (manager); - - if (status != NULL) - *status = g_strdup (priv->requested_status); - if (message != NULL) - *message = g_strdup (priv->requested_status_message); - - return priv->requested_presence; -} - -TpConnectionPresenceType -empathy_account_manager_get_global_presence ( - EmpathyAccountManager *manager, - gchar **status, - gchar **message) -{ - EmpathyAccountManagerPriv *priv = GET_PRIV (manager); - - if (status != NULL) - *status = g_strdup (priv->global_status); - if (message != NULL) - *message = g_strdup (priv->global_status_message); - - return priv->global_presence; -} - -static void -empathy_account_manager_created_cb (TpAccountManager *proxy, - const gchar *account_path, - const GError *error, - gpointer user_data, - GObject *weak_object) -{ - EmpathyAccountManager *manager = EMPATHY_ACCOUNT_MANAGER (weak_object); - EmpathyAccountManagerPriv *priv = GET_PRIV (manager); - GSimpleAsyncResult *my_res = user_data; - EmpathyAccount *account; - - if (error != NULL) - { - g_simple_async_result_set_from_error (my_res, - (GError *) error); - g_simple_async_result_complete (my_res); - g_object_unref (my_res); - - return; - } - - account = empathy_account_manager_ensure_account (manager, account_path); - - g_hash_table_insert (priv->create_results, account, my_res); -} - -void -empathy_account_manager_create_account_async (EmpathyAccountManager *manager, - const gchar *connection_manager, - const gchar *protocol, - const gchar *display_name, - GHashTable *parameters, - GHashTable *properties, - GAsyncReadyCallback callback, - gpointer user_data) -{ - EmpathyAccountManagerPriv *priv = GET_PRIV (manager); - GSimpleAsyncResult *res; - - res = g_simple_async_result_new - (G_OBJECT (manager), callback, user_data, - empathy_account_manager_create_account_finish); - - tp_cli_account_manager_call_create_account (priv->tp_manager, - -1, - connection_manager, - protocol, - display_name, - parameters, - properties, - empathy_account_manager_created_cb, - res, - NULL, - G_OBJECT (manager)); -} - -EmpathyAccount * -empathy_account_manager_create_account_finish ( - EmpathyAccountManager *manager, GAsyncResult *result, GError **error) -{ - EmpathyAccount *retval; - - if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), - error)) - return NULL; - - g_return_val_if_fail (g_simple_async_result_is_valid (result, - G_OBJECT (manager), empathy_account_manager_create_account_finish), NULL); - - retval = EMPATHY_ACCOUNT (g_simple_async_result_get_op_res_gpointer ( - G_SIMPLE_ASYNC_RESULT (result))); - - return retval; -} - diff --git a/libempathy/empathy-account-manager.h b/libempathy/empathy-account-manager.h deleted file mode 100644 index 7b4ebd9bb..000000000 --- a/libempathy/empathy-account-manager.h +++ /dev/null @@ -1,111 +0,0 @@ -/* -*- Mode: C; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2; -*- */ -/* - * Copyright (C) 2008 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 - * - * Authors: Cosimo Cecchi <cosimo.cecchi@collabora.co.uk> - */ - -#ifndef __EMPATHY_ACCOUNT_MANAGER_H__ -#define __EMPATHY_ACCOUNT_MANAGER_H__ - -#include <glib-object.h> - -#include "empathy-account.h" - -G_BEGIN_DECLS - -#define EMPATHY_TYPE_ACCOUNT_MANAGER (empathy_account_manager_get_type ()) -#define EMPATHY_ACCOUNT_MANAGER(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), \ - EMPATHY_TYPE_ACCOUNT_MANAGER, EmpathyAccountManager)) -#define EMPATHY_ACCOUNT_MANAGER_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), \ - EMPATHY_TYPE_ACCOUNT_MANAGER, EmpathyAccountManagerClass)) -#define EMPATHY_IS_ACCOUNT_MANAGER(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), \ - EMPATHY_TYPE_ACCOUNT_MANAGER)) -#define EMPATHY_IS_ACCOUNT_MANAGER_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), \ - EMPATHY_TYPE_ACCOUNT_MANAGER)) -#define EMPATHY_ACCOUNT_MANAGER_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), \ - EMPATHY_TYPE_ACCOUNT_MANAGER, EmpathyAccountManagerClass)) - -typedef struct _EmpathyAccountManager EmpathyAccountManager; -typedef struct _EmpathyAccountManagerClass EmpathyAccountManagerClass; - -struct _EmpathyAccountManager { - GObject parent; - gpointer priv; -}; - -struct _EmpathyAccountManagerClass { - GObjectClass parent_class; -}; - -GType empathy_account_manager_get_type (void); - -/* public methods */ - -EmpathyAccountManager * empathy_account_manager_dup_singleton (void); - -gboolean empathy_account_manager_is_ready (EmpathyAccountManager *manager); - -int empathy_account_manager_get_connected_accounts - (EmpathyAccountManager *manager); -int empathy_account_manager_get_connecting_accounts - (EmpathyAccountManager *manager); -int empathy_account_manager_get_count - (EmpathyAccountManager *manager); -EmpathyAccount * empathy_account_manager_get_account_for_connection - (EmpathyAccountManager *manager, - TpConnection *connection); -EmpathyAccount * empathy_account_manager_ensure_account - (EmpathyAccountManager *manager, - const gchar *unique_name); -EmpathyAccount * empathy_account_manager_get_account - (EmpathyAccountManager *manager, - const gchar *unique_name); -GList * empathy_account_manager_dup_accounts - (EmpathyAccountManager *manager); -GList * empathy_account_manager_dup_connections - (EmpathyAccountManager *manager); - -void empathy_account_manager_request_global_presence ( - EmpathyAccountManager *manager, - TpConnectionPresenceType type, - const gchar *status, - const gchar *message); - -TpConnectionPresenceType empathy_account_manager_get_requested_global_presence ( - EmpathyAccountManager *manager, - gchar **status, - gchar **message); - -TpConnectionPresenceType empathy_account_manager_get_global_presence ( - EmpathyAccountManager *manager, - gchar **status, - gchar **message); - -void empathy_account_manager_create_account_async ( - EmpathyAccountManager *manager, const gchar *connection_manager, - const gchar *protocol, const gchar *display_name, - GHashTable *parameters, GHashTable *properties, - GAsyncReadyCallback callback, gpointer user_data); - -EmpathyAccount * empathy_account_manager_create_account_finish ( - EmpathyAccountManager *settings, GAsyncResult *result, GError **error); - -G_END_DECLS - -#endif /* __EMPATHY_ACCOUNT_MANAGER_H__ */ - diff --git a/libempathy/empathy-account-settings.c b/libempathy/empathy-account-settings.c index 0acc8006f..f33e43799 100644 --- a/libempathy/empathy-account-settings.c +++ b/libempathy/empathy-account-settings.c @@ -22,14 +22,15 @@ #include <stdio.h> #include <stdlib.h> +#include <telepathy-glib/account-manager.h> #include <telepathy-glib/util.h> #include <telepathy-glib/interfaces.h> #include <telepathy-glib/gtypes.h> #include "empathy-account-settings.h" -#include "empathy-account-manager.h" #include "empathy-connection-managers.h" #include "empathy-utils.h" +#include "empathy-idle.h" #define DEBUG_FLAG EMPATHY_DEBUG_ACCOUNT #include <libempathy/empathy-debug.h> @@ -54,12 +55,11 @@ struct _EmpathyAccountSettingsPriv { gboolean dispose_has_run; EmpathyConnectionManagers *managers; - EmpathyAccountManager *account_manager; - gulong account_manager_ready_id; + TpAccountManager *account_manager; TpConnectionManager *manager; - EmpathyAccount *account; + TpAccount *account; gchar *cm_name; gchar *protocol; gchar *display_name; @@ -72,7 +72,6 @@ struct _EmpathyAccountSettingsPriv GArray *required_params; gulong managers_ready_id; - gulong account_ready_id; GSimpleAsyncResult *apply_result; }; @@ -87,7 +86,7 @@ empathy_account_settings_init (EmpathyAccountSettings *obj) /* allocate any data required by the object here */ priv->managers = empathy_connection_managers_dup_singleton (); - priv->account_manager = empathy_account_manager_dup_singleton (); + priv->account_manager = tp_account_manager_dup (); priv->parameters = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, (GDestroyNotify) tp_g_value_slice_free); @@ -97,8 +96,10 @@ empathy_account_settings_init (EmpathyAccountSettings *obj) static void empathy_account_settings_dispose (GObject *object); static void empathy_account_settings_finalize (GObject *object); -static void empathy_account_settings_ready_cb (GObject *obj, - GParamSpec *spec, gpointer user_data); +static void empathy_account_settings_account_ready_cb (GObject *source_object, + GAsyncResult *result, gpointer user_data); +static void empathy_account_settings_managers_ready_cb (GObject *obj, + GParamSpec *pspec, gpointer user_data); static void empathy_account_settings_check_readyness ( EmpathyAccountSettings *self); @@ -181,11 +182,11 @@ empathy_account_settings_constructed (GObject *object) g_free (priv->protocol); priv->cm_name = - g_strdup (empathy_account_get_connection_manager (priv->account)); + g_strdup (tp_account_get_connection_manager (priv->account)); priv->protocol = - g_strdup (empathy_account_get_protocol (priv->account)); + g_strdup (tp_account_get_protocol (priv->account)); priv->icon_name = g_strdup - (empathy_account_get_icon_name (priv->account)); + (tp_account_get_icon_name (priv->account)); } else { @@ -198,10 +199,10 @@ empathy_account_settings_constructed (GObject *object) if (!priv->ready) { - g_signal_connect (priv->account, "notify::ready", - G_CALLBACK (empathy_account_settings_ready_cb), self); + tp_account_prepare_async (priv->account, NULL, + empathy_account_settings_account_ready_cb, self); g_signal_connect (priv->managers, "notify::ready", - G_CALLBACK (empathy_account_settings_ready_cb), self); + G_CALLBACK (empathy_account_settings_managers_ready_cb), self); } if (G_OBJECT_CLASS ( @@ -229,8 +230,8 @@ empathy_account_settings_class_init ( g_object_class_install_property (object_class, PROP_ACCOUNT, g_param_spec_object ("account", "Account", - "The EmpathyAccount backing these settings", - EMPATHY_TYPE_ACCOUNT, + "The TpAccount backing these settings", + TP_TYPE_ACCOUNT, G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY)); g_object_class_install_property (object_class, PROP_CM_NAME, @@ -293,19 +294,10 @@ empathy_account_settings_dispose (GObject *object) g_object_unref (priv->manager); priv->manager = NULL; - if (priv->account_manager_ready_id != 0) - g_signal_handler_disconnect (priv->account_manager, - priv->account_manager_ready_id); - priv->account_manager_ready_id = 0; - if (priv->account_manager != NULL) g_object_unref (priv->account_manager); priv->account_manager = NULL; - if (priv->account_ready_id != 0) - g_signal_handler_disconnect (priv->account, priv->account_ready_id); - priv->account_ready_id = 0; - if (priv->account != NULL) g_object_unref (priv->account); priv->account = NULL; @@ -360,7 +352,8 @@ empathy_account_settings_check_readyness (EmpathyAccountSettings *self) if (priv->ready) return; - if (priv->account != NULL && !empathy_account_is_ready (priv->account)) + if (priv->account != NULL + && !tp_account_is_prepared (priv->account, TP_ACCOUNT_FEATURE_CORE)) return; if (!empathy_connection_managers_is_ready (priv->managers)) @@ -376,11 +369,11 @@ empathy_account_settings_check_readyness (EmpathyAccountSettings *self) { g_free (priv->display_name); priv->display_name = - g_strdup (empathy_account_get_display_name (priv->account)); + g_strdup (tp_account_get_display_name (priv->account)); g_free (priv->icon_name); priv->icon_name = - g_strdup (empathy_account_get_icon_name (priv->account)); + g_strdup (tp_account_get_icon_name (priv->account)); } tp_protocol = tp_connection_manager_get_protocol (priv->manager, @@ -416,8 +409,27 @@ empathy_account_settings_check_readyness (EmpathyAccountSettings *self) } static void -empathy_account_settings_ready_cb (GObject *obj, - GParamSpec *spec, +empathy_account_settings_account_ready_cb (GObject *source_object, + GAsyncResult *result, + gpointer user_data) +{ + EmpathyAccountSettings *settings = EMPATHY_ACCOUNT_SETTINGS (user_data); + TpAccount *account = TP_ACCOUNT (source_object); + GError *error = NULL; + + if (!tp_account_prepare_finish (account, result, &error)) + { + DEBUG ("Failed to prepare account: %s", error->message); + g_error_free (error); + return; + } + + empathy_account_settings_check_readyness (settings); +} + +static void +empathy_account_settings_managers_ready_cb (GObject *object, + GParamSpec *pspec, gpointer user_data) { EmpathyAccountSettings *settings = EMPATHY_ACCOUNT_SETTINGS (user_data); @@ -438,7 +450,7 @@ empathy_account_settings_new (const gchar *connection_manager, } EmpathyAccountSettings * -empathy_account_settings_new_for_account (EmpathyAccount *account) +empathy_account_settings_new_for_account (TpAccount *account) { return g_object_new (EMPATHY_TYPE_ACCOUNT_SETTINGS, "account", account, @@ -506,7 +518,7 @@ empathy_account_settings_get_display_name (EmpathyAccountSettings *settings) return priv->display_name; } -EmpathyAccount * +TpAccount * empathy_account_settings_get_account (EmpathyAccountSettings *settings) { EmpathyAccountSettingsPriv *priv = GET_PRIV (settings); @@ -621,7 +633,7 @@ empathy_account_settings_get (EmpathyAccountSettings *settings, { const GHashTable *parameters; - parameters = empathy_account_get_parameters (priv->account); + parameters = tp_account_get_parameters (priv->account); result = tp_asv_lookup (parameters, param); if (result != NULL) @@ -910,10 +922,10 @@ account_settings_display_name_set_cb (GObject *src, gpointer user_data) { GError *error = NULL; - EmpathyAccount *account = EMPATHY_ACCOUNT (src); + TpAccount *account = TP_ACCOUNT (src); GSimpleAsyncResult *set_result = user_data; - empathy_account_set_display_name_finish (account, res, &error); + tp_account_set_display_name_finish (account, res, &error); if (error != NULL) { @@ -950,7 +962,7 @@ empathy_account_settings_set_display_name_async ( return; } - empathy_account_set_display_name_async (priv->account, name, + tp_account_set_display_name_async (priv->account, name, account_settings_display_name_set_cb, result); } @@ -977,10 +989,10 @@ account_settings_icon_name_set_cb (GObject *src, gpointer user_data) { GError *error = NULL; - EmpathyAccount *account = EMPATHY_ACCOUNT (src); + TpAccount *account = TP_ACCOUNT (src); GSimpleAsyncResult *set_result = user_data; - empathy_account_set_icon_name_finish (account, res, &error); + tp_account_set_icon_name_finish (account, res, &error); if (error != NULL) { @@ -1017,7 +1029,7 @@ empathy_account_settings_set_icon_name_async ( return; } - empathy_account_set_icon_name_async (priv->account, name, + tp_account_set_icon_name_async (priv->account, name, account_settings_icon_name_set_cb, result); } @@ -1048,8 +1060,8 @@ empathy_account_settings_account_updated (GObject *source, GSimpleAsyncResult *r; GError *error = NULL; - if (!empathy_account_update_settings_finish (EMPATHY_ACCOUNT (source), - result, &error)) + if (!tp_account_update_parameters_finish (TP_ACCOUNT (source), + result, NULL, &error)) { g_simple_async_result_set_from_error (priv->apply_result, error); g_error_free (error); @@ -1073,12 +1085,12 @@ empathy_account_settings_created_cb (GObject *source, { EmpathyAccountSettings *settings = EMPATHY_ACCOUNT_SETTINGS (user_data); EmpathyAccountSettingsPriv *priv = GET_PRIV (settings); - EmpathyAccount *account; + TpAccount *account; GError *error = NULL; GSimpleAsyncResult *r; - account = empathy_account_manager_create_account_finish ( - EMPATHY_ACCOUNT_MANAGER (source), result, &error); + account = tp_account_manager_create_account_finish ( + TP_ACCOUNT_MANAGER (source), result, &error); if (account == NULL) { @@ -1106,11 +1118,13 @@ empathy_account_settings_do_create_account (EmpathyAccountSettings *settings) TpConnectionPresenceType type; gchar *status; gchar *message; + EmpathyIdle *idle; properties = tp_asv_new (NULL, NULL); - type = empathy_account_manager_get_requested_global_presence - (priv->account_manager, &status, &message); + idle = empathy_idle_dup_singleton (); + type = empathy_idle_get_requested_presence (idle, &status, &message); + g_object_unref (idle); if (type != TP_CONNECTION_PRESENCE_TYPE_UNSET) { @@ -1142,7 +1156,7 @@ empathy_account_settings_do_create_account (EmpathyAccountSettings *settings) tp_asv_set_string (properties, TP_IFACE_ACCOUNT ".Icon", priv->icon_name); - empathy_account_manager_create_account_async (priv->account_manager, + tp_account_manager_create_account_async (priv->account_manager, priv->cm_name, priv->protocol, priv->display_name, priv->parameters, properties, empathy_account_settings_created_cb, @@ -1152,22 +1166,24 @@ empathy_account_settings_do_create_account (EmpathyAccountSettings *settings) } static void -empathy_account_settings_manager_ready_cb (EmpathyAccountManager *manager, - GParamSpec *spec, +empathy_account_settings_manager_ready_cb (GObject *source_object, + GAsyncResult *result, gpointer user_data) { EmpathyAccountSettings *settings = EMPATHY_ACCOUNT_SETTINGS (user_data); EmpathyAccountSettingsPriv *priv = GET_PRIV (settings); + TpAccountManager *account_manager = TP_ACCOUNT_MANAGER (source_object); + GError *error = NULL; - if (empathy_account_manager_is_ready (manager)) + if (!tp_account_manager_prepare_finish (account_manager, result, &error)) { - g_assert (priv->apply_result != NULL && priv->account == NULL); - g_signal_handler_disconnect (priv->account_manager, - priv->account_manager_ready_id); - priv->account_manager_ready_id = 0; - - empathy_account_settings_do_create_account (settings); + DEBUG ("Failed to prepare account manager: %s", error->message); + g_error_free (error); + return; } + + g_assert (priv->apply_result != NULL && priv->account == NULL); + empathy_account_settings_do_create_account (settings); } void @@ -1180,8 +1196,8 @@ empathy_account_settings_apply_async (EmpathyAccountSettings *settings, if (priv->apply_result != NULL) { g_simple_async_report_error_in_idle (G_OBJECT (settings), - callback, user_data, - G_IO_ERROR, G_IO_ERROR_PENDING, "Applying already in progress"); + callback, user_data, + G_IO_ERROR, G_IO_ERROR_PENDING, "Applying already in progress"); return; } @@ -1190,20 +1206,14 @@ empathy_account_settings_apply_async (EmpathyAccountSettings *settings, if (priv->account == NULL) { - if (empathy_account_manager_is_ready (priv->account_manager)) - empathy_account_settings_do_create_account (settings); - else - priv->account_manager_ready_id = g_signal_connect ( - priv->account_manager, - "notify::ready", - G_CALLBACK (empathy_account_settings_manager_ready_cb), - settings); + tp_account_manager_prepare_async (priv->account_manager, NULL, + empathy_account_settings_manager_ready_cb, settings); } else { - empathy_account_update_settings_async (priv->account, - priv->parameters, (const gchar **)priv->unset_parameters->data, - empathy_account_settings_account_updated, settings); + tp_account_update_parameters_async (priv->account, + priv->parameters, (const gchar **)priv->unset_parameters->data, + empathy_account_settings_account_updated, settings); } } @@ -1224,12 +1234,12 @@ empathy_account_settings_apply_finish (EmpathyAccountSettings *settings, gboolean empathy_account_settings_has_account (EmpathyAccountSettings *settings, - EmpathyAccount *account) + TpAccount *account) { EmpathyAccountSettingsPriv *priv; g_return_val_if_fail (EMPATHY_IS_ACCOUNT_SETTINGS (settings), FALSE); - g_return_val_if_fail (EMPATHY_IS_ACCOUNT (account), FALSE); + g_return_val_if_fail (TP_IS_ACCOUNT (account), FALSE); priv = GET_PRIV (settings); @@ -1262,7 +1272,7 @@ empathy_account_settings_is_valid (EmpathyAccountSettings *settings) { const GHashTable *account_params; - account_params = empathy_account_get_parameters (priv->account); + account_params = tp_account_get_parameters (priv->account); if (tp_asv_lookup (account_params, current)) continue; } diff --git a/libempathy/empathy-account-settings.h b/libempathy/empathy-account-settings.h index c7d263e3b..0ea9b5567 100644 --- a/libempathy/empathy-account-settings.h +++ b/libempathy/empathy-account-settings.h @@ -24,7 +24,7 @@ #include <glib-object.h> #include <gio/gio.h> -#include <libempathy/empathy-account.h> +#include <telepathy-glib/account.h> #include <telepathy-glib/connection-manager.h> G_BEGIN_DECLS @@ -66,7 +66,7 @@ EmpathyAccountSettings * empathy_account_settings_new ( const char *display_name); EmpathyAccountSettings * empathy_account_settings_new_for_account ( - EmpathyAccount *account); + TpAccount *account); gboolean empathy_account_settings_is_ready (EmpathyAccountSettings *settings); @@ -74,11 +74,11 @@ const gchar *empathy_account_settings_get_cm (EmpathyAccountSettings *settings); const gchar *empathy_account_settings_get_protocol ( EmpathyAccountSettings *settings); -EmpathyAccount *empathy_account_settings_get_account ( +TpAccount *empathy_account_settings_get_account ( EmpathyAccountSettings *settings); gboolean empathy_account_settings_has_account ( - EmpathyAccountSettings *settings, EmpathyAccount *account); + EmpathyAccountSettings *settings, TpAccount *account); TpConnectionManagerParam *empathy_account_settings_get_tp_params ( EmpathyAccountSettings *settings); diff --git a/libempathy/empathy-account.c b/libempathy/empathy-account.c deleted file mode 100644 index fb1b2756d..000000000 --- a/libempathy/empathy-account.c +++ /dev/null @@ -1,1305 +0,0 @@ -/* - * empathy-account.c - Source for EmpathyAccount - * Copyright (C) 2009 Collabora Ltd. - * @author Sjoerd Simons <sjoerd.simons@collabora.co.uk> - * - * 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 - */ - -#include <stdio.h> -#include <stdlib.h> -#include <string.h> - -#include <telepathy-glib/enums.h> -#include <telepathy-glib/dbus.h> -#include <telepathy-glib/account.h> -#include <telepathy-glib/gtypes.h> -#include <telepathy-glib/util.h> -#include <telepathy-glib/interfaces.h> -#include <telepathy-glib/defs.h> - -#define DEBUG_FLAG EMPATHY_DEBUG_ACCOUNT -#include <libempathy/empathy-debug.h> - -#include <glib/gi18n-lib.h> - -#include "empathy-account.h" -#include "empathy-account-manager.h" -#include "empathy-utils.h" -#include "empathy-marshal.h" - -/* signals */ -enum { - STATUS_CHANGED, - PRESENCE_CHANGED, - REMOVED, - LAST_SIGNAL -}; - -static guint signals[LAST_SIGNAL]; - -/* properties */ -enum { - PROP_ENABLED = 1, - PROP_PRESENCE, - PROP_STATUS, - PROP_STATUS_MESSAGE, - PROP_READY, - PROP_CONNECTION_STATUS, - PROP_CONNECTION_STATUS_REASON, - PROP_CONNECTION, - PROP_UNIQUE_NAME, - PROP_DBUS_DAEMON, - PROP_DISPLAY_NAME -}; - -G_DEFINE_TYPE(EmpathyAccount, empathy_account, G_TYPE_OBJECT) - -/* private structure */ -typedef struct _EmpathyAccountPriv EmpathyAccountPriv; - -struct _EmpathyAccountPriv -{ - gboolean dispose_has_run; - - TpConnection *connection; - guint connection_invalidated_id; - - TpConnectionStatus connection_status; - TpConnectionStatusReason reason; - - TpConnectionPresenceType presence; - gchar *status; - gchar *message; - - gboolean enabled; - gboolean valid; - gboolean ready; - gboolean removed; - /* Timestamp when the connection got connected in seconds since the epoch */ - glong connect_time; - - gchar *cm_name; - gchar *proto_name; - gchar *icon_name; - - gchar *unique_name; - gchar *display_name; - TpDBusDaemon *dbus; - - TpAccount *account; - GHashTable *parameters; -}; - -#define GET_PRIV(obj) EMPATHY_GET_PRIV (obj, EmpathyAccount) - -static void _empathy_account_set_connection (EmpathyAccount *account, - const gchar *path); - -static void -empathy_account_init (EmpathyAccount *obj) -{ - EmpathyAccountPriv *priv; - - priv = G_TYPE_INSTANCE_GET_PRIVATE (obj, - EMPATHY_TYPE_ACCOUNT, EmpathyAccountPriv); - - obj->priv = priv; - - priv->connection_status = TP_CONNECTION_STATUS_DISCONNECTED; -} - -static void -empathy_account_set_property (GObject *object, - guint prop_id, - const GValue *value, - GParamSpec *pspec) -{ - EmpathyAccount *account = EMPATHY_ACCOUNT (object); - EmpathyAccountPriv *priv = GET_PRIV (account); - - switch (prop_id) - { - case PROP_ENABLED: - empathy_account_set_enabled_async (account, - g_value_get_boolean (value), NULL, NULL); - break; - case PROP_UNIQUE_NAME: - priv->unique_name = g_value_dup_string (value); - break; - case PROP_DBUS_DAEMON: - priv->dbus = g_value_get_object (value); - break; - default: - G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); - break; - } -} - -static void -empathy_account_get_property (GObject *object, - guint prop_id, - GValue *value, - GParamSpec *pspec) -{ - EmpathyAccount *account = EMPATHY_ACCOUNT (object); - EmpathyAccountPriv *priv = GET_PRIV (account); - - switch (prop_id) - { - case PROP_ENABLED: - g_value_set_boolean (value, priv->enabled); - break; - case PROP_READY: - g_value_set_boolean (value, priv->ready); - break; - case PROP_PRESENCE: - g_value_set_uint (value, priv->presence); - break; - case PROP_STATUS: - g_value_set_string (value, priv->status); - break; - case PROP_STATUS_MESSAGE: - g_value_set_string (value, priv->message); - break; - case PROP_CONNECTION_STATUS: - g_value_set_uint (value, priv->connection_status); - break; - case PROP_CONNECTION_STATUS_REASON: - g_value_set_uint (value, priv->reason); - break; - case PROP_CONNECTION: - g_value_set_object (value, - empathy_account_get_connection (account)); - break; - case PROP_UNIQUE_NAME: - g_value_set_string (value, - empathy_account_get_unique_name (account)); - break; - case PROP_DISPLAY_NAME: - g_value_set_string (value, - empathy_account_get_display_name (account)); - break; - case PROP_DBUS_DAEMON: - g_value_set_object (value, priv->dbus); - break; - default: - G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); - break; - } -} - -static void -empathy_account_update (EmpathyAccount *account, - GHashTable *properties) -{ - EmpathyAccountPriv *priv = GET_PRIV (account); - GValueArray *arr; - TpConnectionStatus old_s = priv->connection_status; - gboolean presence_changed = FALSE; - - if (g_hash_table_lookup (properties, "ConnectionStatus") != NULL) - priv->connection_status = - tp_asv_get_int32 (properties, "ConnectionStatus", NULL); - - if (g_hash_table_lookup (properties, "ConnectionStatusReason") != NULL) - priv->reason = tp_asv_get_int32 (properties, - "ConnectionStatusReason", NULL); - - if (g_hash_table_lookup (properties, "CurrentPresence") != NULL) - { - presence_changed = TRUE; - arr = tp_asv_get_boxed (properties, "CurrentPresence", - TP_STRUCT_TYPE_SIMPLE_PRESENCE); - priv->presence = g_value_get_uint (g_value_array_get_nth (arr, 0)); - - g_free (priv->status); - priv->status = g_value_dup_string (g_value_array_get_nth (arr, 1)); - - g_free (priv->message); - priv->message = g_value_dup_string (g_value_array_get_nth (arr, 2)); - } - - if (g_hash_table_lookup (properties, "DisplayName") != NULL) - { - g_free (priv->display_name); - priv->display_name = - g_strdup (tp_asv_get_string (properties, "DisplayName")); - g_object_notify (G_OBJECT (account), "display-name"); - } - - if (g_hash_table_lookup (properties, "Icon") != NULL) - { - const gchar *icon_name; - - icon_name = tp_asv_get_string (properties, "Icon"); - - g_free (priv->icon_name); - - if (EMP_STR_EMPTY (icon_name)) - priv->icon_name = empathy_protocol_icon_name (priv->proto_name); - else - priv->icon_name = g_strdup (icon_name); - } - - if (g_hash_table_lookup (properties, "Enabled") != NULL) - { - gboolean enabled = tp_asv_get_boolean (properties, "Enabled", NULL); - if (priv->enabled != enabled) - { - priv->enabled = enabled; - g_object_notify (G_OBJECT (account), "enabled"); - } - } - - if (g_hash_table_lookup (properties, "Valid") != NULL) - priv->valid = tp_asv_get_boolean (properties, "Valid", NULL); - - if (g_hash_table_lookup (properties, "Parameters") != NULL) - { - GHashTable *parameters; - - parameters = tp_asv_get_boxed (properties, "Parameters", - TP_HASH_TYPE_STRING_VARIANT_MAP); - - if (priv->parameters != NULL) - g_hash_table_unref (priv->parameters); - - priv->parameters = g_boxed_copy (TP_HASH_TYPE_STRING_VARIANT_MAP, - parameters); - } - - if (!priv->ready) - { - priv->ready = TRUE; - g_object_notify (G_OBJECT (account), "ready"); - } - - if (priv->connection_status != old_s) - { - if (priv->connection_status == TP_CONNECTION_STATUS_CONNECTED) - { - GTimeVal val; - g_get_current_time (&val); - - priv->connect_time = val.tv_sec; - } - - g_signal_emit (account, signals[STATUS_CHANGED], 0, - old_s, priv->connection_status, priv->reason); - - g_object_notify (G_OBJECT (account), "connection-status"); - g_object_notify (G_OBJECT (account), "connection-status-reason"); - } - - if (presence_changed) - { - g_signal_emit (account, signals[PRESENCE_CHANGED], 0, - priv->presence, priv->status, priv->message); - g_object_notify (G_OBJECT (account), "presence"); - g_object_notify (G_OBJECT (account), "status"); - g_object_notify (G_OBJECT (account), "status-message"); - } - - if (g_hash_table_lookup (properties, "Connection") != NULL) - { - const gchar *conn_path = - tp_asv_get_object_path (properties, "Connection"); - - _empathy_account_set_connection (account, conn_path); - } -} - -static void -empathy_account_properties_changed (TpAccount *proxy, - GHashTable *properties, - gpointer user_data, - GObject *weak_object) -{ - EmpathyAccount *account = EMPATHY_ACCOUNT (weak_object); - EmpathyAccountPriv *priv = GET_PRIV (account); - - if (!priv->ready) - return; - - empathy_account_update (account, properties); -} - -static void -empathy_account_removed_cb (TpAccount *proxy, - gpointer user_data, - GObject *weak_object) -{ - EmpathyAccount *account = EMPATHY_ACCOUNT (weak_object); - EmpathyAccountPriv *priv = GET_PRIV (account); - - if (priv->removed) - return; - - priv->removed = TRUE; - - g_signal_emit (account, signals[REMOVED], 0); -} - -static void -empathy_account_got_all_cb (TpProxy *proxy, - GHashTable *properties, - const GError *error, - gpointer user_data, - GObject *weak_object) -{ - EmpathyAccount *account = EMPATHY_ACCOUNT (weak_object); - - DEBUG ("Got whole set of properties for %s", - empathy_account_get_unique_name (account)); - - if (error != NULL) - { - DEBUG ("Failed to get the initial set of account properties: %s", - error->message); - return; - } - - empathy_account_update (account, properties); -} - -static gchar * -empathy_account_unescape_protocol (const gchar *protocol, gssize len) -{ - gchar *result, *escape; - /* Bad implementation might accidentally use tp_escape_as_identifier, - * which escapes - in the wrong way... */ - if ((escape = g_strstr_len (protocol, len, "_2d")) != NULL) - { - GString *str; - const gchar *input; - - str = g_string_new (""); - input = protocol; - do { - g_string_append_len (str, input, escape - input); - g_string_append_c (str, '-'); - - len -= escape - input + 3; - input = escape + 3; - } while ((escape = g_strstr_len (input, len, "_2d")) != NULL); - - g_string_append_len (str, input, len); - - result = g_string_free (str, FALSE); - } - else - { - result = g_strndup (protocol, len); - } - - g_strdelimit (result, "_", '-'); - - return result; -} - -static gboolean -empathy_account_parse_unique_name (const gchar *bus_name, - gchar **protocol, gchar **manager) -{ - const gchar *proto, *proto_end; - const gchar *cm, *cm_end; - - g_return_val_if_fail ( - g_str_has_prefix (bus_name, TP_ACCOUNT_OBJECT_PATH_BASE), FALSE); - - cm = bus_name + strlen (TP_ACCOUNT_OBJECT_PATH_BASE); - - for (cm_end = cm; *cm_end != '/' && *cm_end != '\0'; cm_end++) - /* pass */; - - if (*cm_end == '\0') - return FALSE; - - if (cm_end == '\0') - return FALSE; - - proto = cm_end + 1; - - for (proto_end = proto; *proto_end != '/' && *proto_end != '\0'; proto_end++) - /* pass */; - - if (*proto_end == '\0') - return FALSE; - - if (protocol != NULL) - { - *protocol = empathy_account_unescape_protocol (proto, proto_end - proto); - } - - if (manager != NULL) - *manager = g_strndup (cm, cm_end - cm); - - return TRUE; -} - -static void -account_invalidated_cb (TpProxy *proxy, guint domain, gint code, - gchar *message, gpointer user_data) -{ - EmpathyAccount *account = EMPATHY_ACCOUNT (user_data); - EmpathyAccountPriv *priv = GET_PRIV (account); - - if (priv->removed) - return; - - priv->removed = TRUE; - - g_signal_emit (account, signals[REMOVED], 0); -} - -static void -empathy_account_constructed (GObject *object) -{ - EmpathyAccount *account = EMPATHY_ACCOUNT (object); - EmpathyAccountPriv *priv = GET_PRIV (account); - - priv->account = tp_account_new (priv->dbus, priv->unique_name, NULL); - - g_signal_connect (priv->account, "invalidated", - G_CALLBACK (account_invalidated_cb), object); - - empathy_account_parse_unique_name (priv->unique_name, - &(priv->proto_name), &(priv->cm_name)); - - priv->icon_name = empathy_protocol_icon_name (priv->proto_name); - - tp_cli_account_connect_to_account_property_changed (priv->account, - empathy_account_properties_changed, - NULL, NULL, object, NULL); - - tp_cli_account_connect_to_removed (priv->account, - empathy_account_removed_cb, - NULL, NULL, object, NULL); - - empathy_account_refresh_properties (account); -} - -static void empathy_account_dispose (GObject *object); -static void empathy_account_finalize (GObject *object); - -static void -empathy_account_class_init (EmpathyAccountClass *empathy_account_class) -{ - GObjectClass *object_class = G_OBJECT_CLASS (empathy_account_class); - - g_type_class_add_private (empathy_account_class, - sizeof (EmpathyAccountPriv)); - - object_class->set_property = empathy_account_set_property; - object_class->get_property = empathy_account_get_property; - object_class->dispose = empathy_account_dispose; - object_class->finalize = empathy_account_finalize; - object_class->constructed = empathy_account_constructed; - - g_object_class_install_property (object_class, PROP_ENABLED, - g_param_spec_boolean ("enabled", - "Enabled", - "Whether this account is enabled or not", - FALSE, - G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE)); - - g_object_class_install_property (object_class, PROP_READY, - g_param_spec_boolean ("ready", - "Ready", - "Whether this account is ready to be used", - FALSE, - G_PARAM_STATIC_STRINGS | G_PARAM_READABLE)); - - g_object_class_install_property (object_class, PROP_PRESENCE, - g_param_spec_uint ("presence", - "Presence", - "The account connections presence type", - 0, - NUM_TP_CONNECTION_PRESENCE_TYPES, - TP_CONNECTION_PRESENCE_TYPE_UNSET, - G_PARAM_STATIC_STRINGS | G_PARAM_READABLE)); - - g_object_class_install_property (object_class, PROP_STATUS, - g_param_spec_string ("status", - "Status", - "The Status string of the account", - NULL, - G_PARAM_STATIC_STRINGS | G_PARAM_READABLE)); - - g_object_class_install_property (object_class, PROP_STATUS_MESSAGE, - g_param_spec_string ("status-message", - "status-message", - "The Status message string of the account", - NULL, - G_PARAM_STATIC_STRINGS | G_PARAM_READABLE)); - - g_object_class_install_property (object_class, PROP_CONNECTION_STATUS, - g_param_spec_uint ("connection-status", - "ConnectionStatus", - "The accounts connections status type", - 0, - NUM_TP_CONNECTION_STATUSES, - TP_CONNECTION_STATUS_DISCONNECTED, - G_PARAM_STATIC_STRINGS | G_PARAM_READABLE)); - - g_object_class_install_property (object_class, PROP_CONNECTION_STATUS_REASON, - g_param_spec_uint ("connection-status-reason", - "ConnectionStatusReason", - "The account connections status reason", - 0, - NUM_TP_CONNECTION_STATUS_REASONS, - TP_CONNECTION_STATUS_REASON_NONE_SPECIFIED, - G_PARAM_STATIC_STRINGS | G_PARAM_READABLE)); - - g_object_class_install_property (object_class, PROP_CONNECTION, - g_param_spec_object ("connection", - "Connection", - "The accounts connection", - TP_TYPE_CONNECTION, - G_PARAM_STATIC_STRINGS | G_PARAM_READABLE)); - - g_object_class_install_property (object_class, PROP_UNIQUE_NAME, - g_param_spec_string ("unique-name", - "UniqueName", - "The accounts unique name", - NULL, - G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY)); - - g_object_class_install_property (object_class, PROP_DBUS_DAEMON, - g_param_spec_object ("dbus-daemon", - "dbus-daemon", - "The Tp Dbus daemon on which this account exists", - TP_TYPE_DBUS_DAEMON, - G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY)); - - g_object_class_install_property (object_class, PROP_DISPLAY_NAME, - g_param_spec_string ("display-name", - "DisplayName", - "The accounts display name", - NULL, - G_PARAM_STATIC_STRINGS | G_PARAM_READABLE)); - - signals[STATUS_CHANGED] = g_signal_new ("status-changed", - G_TYPE_FROM_CLASS (object_class), - G_SIGNAL_RUN_LAST, - 0, NULL, NULL, - _empathy_marshal_VOID__UINT_UINT_UINT, - G_TYPE_NONE, 3, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_UINT); - - signals[PRESENCE_CHANGED] = g_signal_new ("presence-changed", - G_TYPE_FROM_CLASS (object_class), - G_SIGNAL_RUN_LAST, - 0, NULL, NULL, - _empathy_marshal_VOID__UINT_STRING_STRING, - G_TYPE_NONE, 3, G_TYPE_UINT, G_TYPE_STRING, G_TYPE_STRING); - - signals[REMOVED] = g_signal_new ("removed", - G_TYPE_FROM_CLASS (object_class), - G_SIGNAL_RUN_LAST, - 0, NULL, NULL, - g_cclosure_marshal_VOID__VOID, - G_TYPE_NONE, 0); -} - -static void -empathy_account_free_connection (EmpathyAccount *account) -{ - EmpathyAccountPriv *priv = GET_PRIV (account); - TpConnection *conn; - - if (priv->connection == NULL) - return; - - conn = priv->connection; - priv->connection = NULL; - - if (priv->connection_invalidated_id != 0) - g_signal_handler_disconnect (conn, priv->connection_invalidated_id); - priv->connection_invalidated_id = 0; - - g_object_unref (conn); -} - -void -empathy_account_dispose (GObject *object) -{ - EmpathyAccount *self = EMPATHY_ACCOUNT (object); - EmpathyAccountPriv *priv = GET_PRIV (self); - - if (priv->dispose_has_run) - return; - - priv->dispose_has_run = TRUE; - - empathy_account_free_connection (self); - - /* release any references held by the object here */ - if (G_OBJECT_CLASS (empathy_account_parent_class)->dispose != NULL) - G_OBJECT_CLASS (empathy_account_parent_class)->dispose (object); -} - -void -empathy_account_finalize (GObject *object) -{ - EmpathyAccountPriv *priv = GET_PRIV (object); - - g_free (priv->status); - g_free (priv->message); - - g_free (priv->cm_name); - g_free (priv->proto_name); - g_free (priv->icon_name); - g_free (priv->display_name); - - /* free any data held directly by the object here */ - if (G_OBJECT_CLASS (empathy_account_parent_class)->finalize != NULL) - G_OBJECT_CLASS (empathy_account_parent_class)->finalize (object); -} - -gboolean -empathy_account_is_just_connected (EmpathyAccount *account) -{ - EmpathyAccountPriv *priv = GET_PRIV (account); - GTimeVal val; - - if (priv->connection_status != TP_CONNECTION_STATUS_CONNECTED) - return FALSE; - - g_get_current_time (&val); - - return (val.tv_sec - priv->connect_time) < 10; -} - -/** - * empathy_account_get_connection: - * @account: a #EmpathyAccount - * - * Get the connection of the account, or NULL if account is offline or the - * connection is not yet ready. This function does not return a new ref. - * - * Returns: the connection of the account. - **/ -TpConnection * -empathy_account_get_connection (EmpathyAccount *account) -{ - EmpathyAccountPriv *priv = GET_PRIV (account); - - if (priv->connection != NULL && - tp_connection_is_ready (priv->connection)) - return priv->connection; - - return NULL; -} - -/** - * empathy_account_get_connection_for_path: - * @account: a #EmpathyAccount - * @patch: the path to connection object for #EmpathyAccount - * - * Get the connection of the account on path. This function does not return a - * new ref. It is not guaranteed that the returned connection object is ready - * - * Returns: the connection of the account. - **/ -TpConnection * -empathy_account_get_connection_for_path (EmpathyAccount *account, - const gchar *path) -{ - EmpathyAccountPriv *priv = GET_PRIV (account); - - /* double-check that the object path is valid */ - if (!tp_dbus_check_valid_object_path (path, NULL)) - return NULL; - - /* Should be a full object path, not the special "/" value */ - if (strlen (path) == 1) - return NULL; - - _empathy_account_set_connection (account, path); - - return priv->connection; -} - -/** - * empathy_account_get_unique_name: - * @account: a #EmpathyAccount - * - * Returns: the unique name of the account. - **/ -const gchar * -empathy_account_get_unique_name (EmpathyAccount *account) -{ - EmpathyAccountPriv *priv = GET_PRIV (account); - - return priv->unique_name; -} - -/** - * empathy_account_get_display_name: - * @account: a #EmpathyAccount - * - * Returns: the display name of the account. - **/ -const gchar * -empathy_account_get_display_name (EmpathyAccount *account) -{ - EmpathyAccountPriv *priv = GET_PRIV (account); - - return priv->display_name; -} - -gboolean -empathy_account_is_valid (EmpathyAccount *account) -{ - EmpathyAccountPriv *priv = GET_PRIV (account); - - return priv->valid; -} - -const gchar * -empathy_account_get_connection_manager (EmpathyAccount *account) -{ - EmpathyAccountPriv *priv = GET_PRIV (account); - - return priv->cm_name; -} - -const gchar * -empathy_account_get_protocol (EmpathyAccount *account) -{ - EmpathyAccountPriv *priv = GET_PRIV (account); - - return priv->proto_name; -} - -const gchar * -empathy_account_get_icon_name (EmpathyAccount *account) -{ - EmpathyAccountPriv *priv = GET_PRIV (account); - - return priv->icon_name; -} - -const GHashTable * -empathy_account_get_parameters (EmpathyAccount *account) -{ - EmpathyAccountPriv *priv = GET_PRIV (account); - - return priv->parameters; -} - -gboolean -empathy_account_is_enabled (EmpathyAccount *account) -{ - EmpathyAccountPriv *priv = GET_PRIV (account); - - return priv->enabled; -} - -gboolean -empathy_account_is_ready (EmpathyAccount *account) -{ - EmpathyAccountPriv *priv = GET_PRIV (account); - - return priv->ready; -} - - -EmpathyAccount * -empathy_account_new (TpDBusDaemon *dbus, - const gchar *unique_name) -{ - return EMPATHY_ACCOUNT (g_object_new (EMPATHY_TYPE_ACCOUNT, - "dbus-daemon", dbus, - "unique-name", unique_name, - NULL)); -} - -static void -empathy_account_connection_ready_cb (TpConnection *connection, - const GError *error, - gpointer user_data) -{ - EmpathyAccount *account = EMPATHY_ACCOUNT (user_data); - - if (error != NULL) - { - DEBUG ("(%s) Connection failed to become ready: %s", - empathy_account_get_unique_name (account), error->message); - empathy_account_free_connection (account); - } - else - { - DEBUG ("(%s) Connection ready", - empathy_account_get_unique_name (account)); - g_object_notify (G_OBJECT (account), "connection"); - } -} - -static void -_empathy_account_connection_invalidated_cb (TpProxy *self, - guint domain, - gint code, - gchar *message, - gpointer user_data) -{ - EmpathyAccount *account = EMPATHY_ACCOUNT (user_data); - EmpathyAccountPriv *priv = GET_PRIV (account); - - if (priv->connection == NULL) - return; - - DEBUG ("(%s) Connection invalidated", - empathy_account_get_unique_name (account)); - - g_assert (priv->connection == TP_CONNECTION (self)); - - empathy_account_free_connection (account); - - g_object_notify (G_OBJECT (account), "connection"); -} - -static void -_empathy_account_set_connection (EmpathyAccount *account, - const gchar *path) -{ - EmpathyAccountPriv *priv = GET_PRIV (account); - - if (priv->connection != NULL) - { - const gchar *current; - - current = tp_proxy_get_object_path (priv->connection); - if (!tp_strdiff (current, path)) - return; - } - - empathy_account_free_connection (account); - - if (tp_strdiff ("/", path)) - { - GError *error = NULL; - priv->connection = tp_connection_new (priv->dbus, NULL, path, &error); - - if (priv->connection == NULL) - { - DEBUG ("Failed to create a new TpConnection: %s", - error->message); - g_error_free (error); - } - else - { - priv->connection_invalidated_id = g_signal_connect (priv->connection, - "invalidated", - G_CALLBACK (_empathy_account_connection_invalidated_cb), account); - - DEBUG ("Readying connection for %s", priv->unique_name); - /* notify a change in the connection property when it's ready */ - tp_connection_call_when_ready (priv->connection, - empathy_account_connection_ready_cb, account); - } - } - - g_object_notify (G_OBJECT (account), "connection"); -} - -static void -account_enabled_set_cb (TpProxy *proxy, - const GError *error, - gpointer user_data, - GObject *weak_object) -{ - GSimpleAsyncResult *result = user_data; - - if (error != NULL) - g_simple_async_result_set_from_error (result, (GError *) error); - - g_simple_async_result_complete (result); - g_object_unref (result); -} - -gboolean -empathy_account_set_enabled_finish (EmpathyAccount *account, - GAsyncResult *result, - GError **error) -{ - if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), - error) || - !g_simple_async_result_is_valid (result, G_OBJECT (account), - empathy_account_set_enabled_finish)) - return FALSE; - - return TRUE; -} - -void -empathy_account_set_enabled_async (EmpathyAccount *account, - gboolean enabled, - GAsyncReadyCallback callback, - gpointer user_data) -{ - EmpathyAccountPriv *priv = GET_PRIV (account); - EmpathyAccountManager *acc_manager; - GValue value = {0, }; - GSimpleAsyncResult *result = g_simple_async_result_new (G_OBJECT (account), - callback, user_data, empathy_account_set_enabled_finish); - char *status = NULL; - char *status_message = NULL; - TpConnectionPresenceType presence; - - if (priv->enabled == enabled) - { - g_simple_async_result_complete_in_idle (result); - return; - } - - if (enabled) - { - acc_manager = empathy_account_manager_dup_singleton (); - presence = empathy_account_manager_get_requested_global_presence - (acc_manager, &status, &status_message); - - if (presence != TP_CONNECTION_PRESENCE_TYPE_UNSET) - empathy_account_request_presence (account, presence, status, - status_message); - - g_object_unref (acc_manager); - g_free (status); - g_free (status_message); - } - - g_value_init (&value, G_TYPE_BOOLEAN); - g_value_set_boolean (&value, enabled); - - tp_cli_dbus_properties_call_set (TP_PROXY (priv->account), - -1, TP_IFACE_ACCOUNT, "Enabled", &value, - account_enabled_set_cb, result, NULL, G_OBJECT (account)); -} - -static void -account_reconnected_cb (TpAccount *proxy, - const GError *error, - gpointer user_data, - GObject *weak_object) -{ - GSimpleAsyncResult *result = user_data; - - if (error != NULL) - g_simple_async_result_set_from_error (result, (GError *) error); - - g_simple_async_result_complete (result); - g_object_unref (result); -} - -gboolean -empathy_account_reconnect_finish (EmpathyAccount *account, - GAsyncResult *result, - GError **error) -{ - if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), - error) || - !g_simple_async_result_is_valid (result, G_OBJECT (account), - empathy_account_reconnect_finish)) - return FALSE; - - return TRUE; -} - -void -empathy_account_reconnect_async (EmpathyAccount *account, - GAsyncReadyCallback callback, - gpointer user_data) -{ - EmpathyAccountPriv *priv = GET_PRIV (account); - - GSimpleAsyncResult *result = g_simple_async_result_new (G_OBJECT (account), - callback, user_data, empathy_account_reconnect_finish); - - tp_cli_account_call_reconnect (priv->account, - -1, account_reconnected_cb, result, NULL, G_OBJECT (account)); -} - -static void -empathy_account_requested_presence_cb (TpProxy *proxy, - const GError *error, - gpointer user_data, - GObject *weak_object) -{ - if (error) - DEBUG ("Failed to set the requested presence: %s", error->message); -} - - -void -empathy_account_request_presence (EmpathyAccount *account, - TpConnectionPresenceType type, - const gchar *status, - const gchar *message) -{ - EmpathyAccountPriv *priv = GET_PRIV (account); - GValue value = {0, }; - GValueArray *arr; - - g_value_init (&value, TP_STRUCT_TYPE_SIMPLE_PRESENCE); - g_value_take_boxed (&value, dbus_g_type_specialized_construct - (TP_STRUCT_TYPE_SIMPLE_PRESENCE)); - arr = (GValueArray *) g_value_get_boxed (&value); - - g_value_set_uint (arr->values, type); - g_value_set_static_string (arr->values + 1, status); - g_value_set_static_string (arr->values + 2, message); - - tp_cli_dbus_properties_call_set (TP_PROXY (priv->account), - -1, - TP_IFACE_ACCOUNT, - "RequestedPresence", - &value, - empathy_account_requested_presence_cb, - NULL, - NULL, - G_OBJECT (account)); - - g_value_unset (&value); -} - -static void -empathy_account_updated_cb (TpAccount *proxy, - const gchar **reconnect_required, - const GError *error, - gpointer user_data, - GObject *weak_object) -{ - GSimpleAsyncResult *result = G_SIMPLE_ASYNC_RESULT (user_data); - - if (error != NULL) - { - g_simple_async_result_set_from_error (result, (GError *) error); - } - - g_simple_async_result_complete (result); - g_object_unref (G_OBJECT (result)); -} - -void -empathy_account_update_settings_async (EmpathyAccount *account, - GHashTable *parameters, const gchar **unset_parameters, - GAsyncReadyCallback callback, gpointer user_data) -{ - EmpathyAccountPriv *priv = GET_PRIV (account); - GSimpleAsyncResult *result = g_simple_async_result_new (G_OBJECT (account), - callback, user_data, empathy_account_update_settings_finish); - - tp_cli_account_call_update_parameters (priv->account, - -1, - parameters, - unset_parameters, - empathy_account_updated_cb, - result, - NULL, - G_OBJECT (account)); -} - -gboolean -empathy_account_update_settings_finish (EmpathyAccount *account, - GAsyncResult *result, GError **error) -{ - if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), - error)) - return FALSE; - - g_return_val_if_fail (g_simple_async_result_is_valid (result, - G_OBJECT (account), empathy_account_update_settings_finish), FALSE); - - return TRUE; -} - -static void -account_display_name_set_cb (TpProxy *proxy, - const GError *error, - gpointer user_data, - GObject *weak_object) -{ - GSimpleAsyncResult *result = user_data; - - if (error != NULL) - g_simple_async_result_set_from_error (result, (GError *) error); - - g_simple_async_result_complete (result); - g_object_unref (result); -} - -void -empathy_account_set_display_name_async (EmpathyAccount *account, - const char *display_name, - GAsyncReadyCallback callback, - gpointer user_data) -{ - GSimpleAsyncResult *result; - GValue value = {0, }; - EmpathyAccountPriv *priv = GET_PRIV (account); - - if (display_name == NULL) - { - g_simple_async_report_error_in_idle (G_OBJECT (account), - callback, user_data, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT, - _("Can't set an empty display name")); - return; - } - - result = g_simple_async_result_new (G_OBJECT (account), callback, - user_data, empathy_account_set_display_name_finish); - - g_value_init (&value, G_TYPE_STRING); - g_value_set_string (&value, display_name); - - tp_cli_dbus_properties_call_set (priv->account, -1, TP_IFACE_ACCOUNT, - "DisplayName", &value, account_display_name_set_cb, result, NULL, - G_OBJECT (account)); -} - -gboolean -empathy_account_set_display_name_finish (EmpathyAccount *account, - GAsyncResult *result, GError **error) -{ - if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), - error) || - !g_simple_async_result_is_valid (result, G_OBJECT (account), - empathy_account_set_display_name_finish)) - return FALSE; - - return TRUE; -} - -static void -account_icon_name_set_cb (TpProxy *proxy, - const GError *error, - gpointer user_data, - GObject *weak_object) -{ - GSimpleAsyncResult *result = user_data; - - if (error != NULL) - g_simple_async_result_set_from_error (result, (GError *) error); - - g_simple_async_result_complete (result); - g_object_unref (result); -} - -void -empathy_account_set_icon_name_async (EmpathyAccount *account, - const char *icon_name, - GAsyncReadyCallback callback, - gpointer user_data) -{ - GSimpleAsyncResult *result; - GValue value = {0, }; - EmpathyAccountPriv *priv = GET_PRIV (account); - const char *icon_name_set; - - if (icon_name == NULL) - /* settings an empty icon name is allowed */ - icon_name_set = ""; - else - icon_name_set = icon_name; - - result = g_simple_async_result_new (G_OBJECT (account), callback, - user_data, empathy_account_set_icon_name_finish); - - g_value_init (&value, G_TYPE_STRING); - g_value_set_string (&value, icon_name_set); - - tp_cli_dbus_properties_call_set (priv->account, -1, TP_IFACE_ACCOUNT, - "Icon", &value, account_icon_name_set_cb, result, NULL, - G_OBJECT (account)); -} - -gboolean -empathy_account_set_icon_name_finish (EmpathyAccount *account, - GAsyncResult *result, GError **error) -{ - if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), - error) || - !g_simple_async_result_is_valid (result, G_OBJECT (account), - empathy_account_set_icon_name_finish)) - return FALSE; - - return TRUE; -} - -static void -empathy_account_remove_cb (TpAccount *proxy, - const GError *error, - gpointer user_data, - GObject *weak_object) -{ - GSimpleAsyncResult *result = G_SIMPLE_ASYNC_RESULT (user_data); - - if (error != NULL) - { - g_simple_async_result_set_from_error (result, (GError *) error); - } - - g_simple_async_result_complete (result); - g_object_unref (G_OBJECT (result)); -} - -void -empathy_account_remove_async (EmpathyAccount *account, - GAsyncReadyCallback callback, gpointer user_data) -{ - EmpathyAccountPriv *priv = GET_PRIV (account); - GSimpleAsyncResult *result = g_simple_async_result_new (G_OBJECT (account), - callback, user_data, empathy_account_remove_finish); - - tp_cli_account_call_remove (priv->account, - -1, - empathy_account_remove_cb, - result, - NULL, - G_OBJECT (account)); -} - -gboolean -empathy_account_remove_finish (EmpathyAccount *account, - GAsyncResult *result, GError **error) -{ - if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), - error)) - return FALSE; - - g_return_val_if_fail (g_simple_async_result_is_valid (result, - G_OBJECT (account), empathy_account_update_settings_finish), FALSE); - - return TRUE; -} - -void -empathy_account_refresh_properties (EmpathyAccount *account) -{ - EmpathyAccountPriv *priv; - - g_return_if_fail (EMPATHY_IS_ACCOUNT (account)); - - priv = GET_PRIV (account); - - tp_cli_dbus_properties_call_get_all (priv->account, -1, - TP_IFACE_ACCOUNT, - empathy_account_got_all_cb, - NULL, - NULL, - G_OBJECT (account)); -} - diff --git a/libempathy/empathy-account.h b/libempathy/empathy-account.h deleted file mode 100644 index 66f899448..000000000 --- a/libempathy/empathy-account.h +++ /dev/null @@ -1,124 +0,0 @@ -/* - * empathy-account.h - Header for EmpathyAccount - * Copyright (C) 2009 Collabora Ltd. - * @author Sjoerd Simons <sjoerd.simons@collabora.co.uk> - * - * 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 __EMPATHY_ACCOUNT_H__ -#define __EMPATHY_ACCOUNT_H__ - -#include <glib-object.h> -#include <gio/gio.h> - -#include <telepathy-glib/connection.h> - -G_BEGIN_DECLS - -typedef struct _EmpathyAccount EmpathyAccount; -typedef struct _EmpathyAccountClass EmpathyAccountClass; - -struct _EmpathyAccountClass { - GObjectClass parent_class; -}; - -struct _EmpathyAccount { - GObject parent; - gpointer priv; -}; - -GType empathy_account_get_type (void); - -/* TYPE MACROS */ -#define EMPATHY_TYPE_ACCOUNT (empathy_account_get_type ()) -#define EMPATHY_ACCOUNT(obj) \ - (G_TYPE_CHECK_INSTANCE_CAST((obj), EMPATHY_TYPE_ACCOUNT, EmpathyAccount)) -#define EMPATHY_ACCOUNT_CLASS(klass) \ - (G_TYPE_CHECK_CLASS_CAST((klass), EMPATHY_TYPE_ACCOUNT, EmpathyAccountClass)) -#define EMPATHY_IS_ACCOUNT(obj) \ - (G_TYPE_CHECK_INSTANCE_TYPE((obj), EMPATHY_TYPE_ACCOUNT)) -#define EMPATHY_IS_ACCOUNT_CLASS(klass) \ - (G_TYPE_CHECK_CLASS_TYPE((klass), EMPATHY_TYPE_ACCOUNT)) -#define EMPATHY_ACCOUNT_GET_CLASS(obj) \ - (G_TYPE_INSTANCE_GET_CLASS ((obj), EMPATHY_TYPE_ACCOUNT, \ - EmpathyAccountClass)) - -gboolean empathy_account_is_just_connected (EmpathyAccount *account); -TpConnection *empathy_account_get_connection (EmpathyAccount *account); -TpConnection *empathy_account_get_connection_for_path (EmpathyAccount *account, - const gchar *path); -const gchar *empathy_account_get_unique_name (EmpathyAccount *account); -const gchar *empathy_account_get_display_name (EmpathyAccount *account); - -const gchar *empathy_account_get_connection_manager (EmpathyAccount *account); -const gchar *empathy_account_get_protocol (EmpathyAccount *account); -const gchar *empathy_account_get_icon_name (EmpathyAccount *account); - -void empathy_account_set_enabled_async (EmpathyAccount *account, - gboolean enabled, GAsyncReadyCallback callback, gpointer user_data); -gboolean empathy_account_set_enabled_finish (EmpathyAccount *account, - GAsyncResult *result, GError **error); - -void empathy_account_reconnect_async (EmpathyAccount *account, - GAsyncReadyCallback callback, - gpointer user_data); -gboolean empathy_account_reconnect_finish (EmpathyAccount *account, - GAsyncResult *result, - GError **error); - -gboolean empathy_account_is_enabled (EmpathyAccount *account); - -gboolean empathy_account_is_valid (EmpathyAccount *account); -gboolean empathy_account_is_ready (EmpathyAccount *account); - -void empathy_account_update_settings_async (EmpathyAccount *account, - GHashTable *parameters, const gchar **unset_parameters, - GAsyncReadyCallback callback, gpointer user_data); - -gboolean empathy_account_update_settings_finish (EmpathyAccount *account, - GAsyncResult *result, GError **error); - -void empathy_account_remove_async (EmpathyAccount *account, - GAsyncReadyCallback callback, gpointer user_data); -gboolean empathy_account_remove_finish (EmpathyAccount *account, - GAsyncResult *result, GError **error); - -void empathy_account_set_display_name_async (EmpathyAccount *account, - const gchar *display_name, GAsyncReadyCallback callback, - gpointer user_data); -gboolean empathy_account_set_display_name_finish (EmpathyAccount *account, - GAsyncResult *result, GError **error); - -void empathy_account_set_icon_name_async (EmpathyAccount *account, - const gchar *icon_name, GAsyncReadyCallback callback, - gpointer user_data); -gboolean empathy_account_set_icon_name_finish (EmpathyAccount *account, - GAsyncResult *result, GError **error); - -EmpathyAccount *empathy_account_new (TpDBusDaemon *bus_daemon, - const gchar *unique_name); - -void empathy_account_request_presence (EmpathyAccount *account, - TpConnectionPresenceType type, const gchar *status, const gchar *message); - -const GHashTable *empathy_account_get_parameters (EmpathyAccount *account); - -void empathy_account_refresh_properties (EmpathyAccount *account); - - -G_END_DECLS - -#endif /* #ifndef __EMPATHY_ACCOUNT_H__*/ diff --git a/libempathy/empathy-chatroom-manager.c b/libempathy/empathy-chatroom-manager.c index b8c721bcb..56295fe5a 100644 --- a/libempathy/empathy-chatroom-manager.c +++ b/libempathy/empathy-chatroom-manager.c @@ -30,11 +30,11 @@ #include <libxml/parser.h> #include <libxml/tree.h> +#include <telepathy-glib/account-manager.h> #include <telepathy-glib/interfaces.h> #include "empathy-tp-chat.h" #include "empathy-chatroom-manager.h" -#include "empathy-account-manager.h" #include "empathy-utils.h" #define DEBUG_FLAG EMPATHY_DEBUG_OTHER @@ -51,8 +51,8 @@ typedef struct { GList *chatrooms; gchar *file; - EmpathyAccountManager *account_manager; - gulong account_manager_ready_handler_id; + TpAccountManager *account_manager; + /* source id of the autosave timer */ gint save_timer_id; gboolean ready; @@ -105,7 +105,7 @@ chatroom_manager_file_save (EmpathyChatroomManager *manager) continue; } - account_id = empathy_account_get_unique_name ( + account_id = tp_proxy_get_object_path ( empathy_chatroom_get_account (chatroom)); node = xmlNewChild (root, NULL, (const xmlChar *) "chatroom", NULL); @@ -184,7 +184,7 @@ chatroom_manager_parse_chatroom (EmpathyChatroomManager *manager, { EmpathyChatroomManagerPriv *priv; EmpathyChatroom *chatroom; - EmpathyAccount *account; + TpAccount *account; xmlNodePtr child; gchar *str; gchar *name; @@ -230,7 +230,7 @@ chatroom_manager_parse_chatroom (EmpathyChatroomManager *manager, xmlFree (str); } - account = empathy_account_manager_get_account (priv->account_manager, + account = tp_account_manager_ensure_account (priv->account_manager, account_id); if (!account) { g_free (name); @@ -369,12 +369,6 @@ chatroom_manager_finalize (GObject *object) priv = GET_PRIV (object); - if (priv->account_manager_ready_handler_id > 0) - { - g_signal_handler_disconnect (priv->account_manager, - priv->account_manager_ready_handler_id); - } - g_object_unref (priv->account_manager); if (priv->save_timer_id > 0) @@ -402,18 +396,22 @@ chatroom_manager_finalize (GObject *object) } static void -account_manager_ready_cb (GObject *gobject, - GParamSpec *pspec, +account_manager_ready_cb (GObject *source_object, + GAsyncResult *result, gpointer user_data) { EmpathyChatroomManager *self = EMPATHY_CHATROOM_MANAGER (user_data); - EmpathyChatroomManagerPriv *priv = GET_PRIV (self); + TpAccountManager *manager = TP_ACCOUNT_MANAGER (source_object); + GError *error = NULL; - chatroom_manager_get_all (self); + if (!tp_account_manager_prepare_finish (manager, result, &error)) + { + DEBUG ("Failed to prepare account manager: %s", error->message); + g_error_free (error); + return; + } - g_signal_handler_disconnect (gobject, - priv->account_manager_ready_handler_id); - priv->account_manager_ready_handler_id = 0; + chatroom_manager_get_all (self); } static GObject * @@ -440,16 +438,10 @@ empathy_chatroom_manager_constructor (GType type, chatroom_manager_singleton = self; g_object_add_weak_pointer (obj, (gpointer) &chatroom_manager_singleton); - priv->account_manager = empathy_account_manager_dup_singleton (); + priv->account_manager = tp_account_manager_dup (); - priv->account_manager_ready_handler_id = 0; - - if (empathy_account_manager_is_ready (priv->account_manager)) - chatroom_manager_get_all (self); - else - priv->account_manager_ready_handler_id = g_signal_connect ( - G_OBJECT (priv->account_manager), "notify::ready", - G_CALLBACK (account_manager_ready_cb), self); + tp_account_manager_prepare_async (priv->account_manager, NULL, + account_manager_ready_cb, self); if (priv->file == NULL) { @@ -612,7 +604,7 @@ empathy_chatroom_manager_remove (EmpathyChatroomManager *manager, EmpathyChatroom * empathy_chatroom_manager_find (EmpathyChatroomManager *manager, - EmpathyAccount *account, + TpAccount *account, const gchar *room) { EmpathyChatroomManagerPriv *priv; @@ -625,7 +617,7 @@ empathy_chatroom_manager_find (EmpathyChatroomManager *manager, for (l = priv->chatrooms; l; l = l->next) { EmpathyChatroom *chatroom; - EmpathyAccount *this_account; + TpAccount *this_account; const gchar *this_room; chatroom = l->data; @@ -643,7 +635,7 @@ empathy_chatroom_manager_find (EmpathyChatroomManager *manager, GList * empathy_chatroom_manager_get_chatrooms (EmpathyChatroomManager *manager, - EmpathyAccount *account) + TpAccount *account) { EmpathyChatroomManagerPriv *priv; GList *chatrooms, *l; @@ -672,7 +664,7 @@ empathy_chatroom_manager_get_chatrooms (EmpathyChatroomManager *manager, guint empathy_chatroom_manager_get_count (EmpathyChatroomManager *manager, - EmpathyAccount *account) + TpAccount *account) { EmpathyChatroomManagerPriv *priv; GList *l; @@ -731,14 +723,13 @@ static void chatroom_manager_observe_channel_cb (EmpathyDispatcher *dispatcher, EmpathyDispatchOperation *operation, gpointer manager) { - EmpathyChatroomManagerPriv *priv = GET_PRIV (manager); EmpathyChatroom *chatroom; TpChannel *channel; EmpathyTpChat *chat; const gchar *roomname; GQuark channel_type; TpHandleType handle_type; - EmpathyAccount *account; + TpAccount *account; TpConnection *connection; channel_type = empathy_dispatch_operation_get_channel_type_id (operation); @@ -756,8 +747,7 @@ chatroom_manager_observe_channel_cb (EmpathyDispatcher *dispatcher, chat = EMPATHY_TP_CHAT ( empathy_dispatch_operation_get_channel_wrapper (operation)); connection = empathy_tp_chat_get_connection (chat); - account = empathy_account_manager_get_account_for_connection ( - priv->account_manager, connection); + account = empathy_get_account_for_connection (connection); roomname = empathy_tp_chat_get_id (chat); diff --git a/libempathy/empathy-chatroom-manager.h b/libempathy/empathy-chatroom-manager.h index a6038f7fc..8ee2a897a 100644 --- a/libempathy/empathy-chatroom-manager.h +++ b/libempathy/empathy-chatroom-manager.h @@ -27,7 +27,8 @@ #include <glib-object.h> -#include "empathy-account.h" +#include <telepathy-glib/account.h> + #include "empathy-chatroom.h" #include "empathy-dispatcher.h" @@ -59,12 +60,12 @@ gboolean empathy_chatroom_manager_add (EmpathyChatroomMa void empathy_chatroom_manager_remove (EmpathyChatroomManager *manager, EmpathyChatroom *chatroom); EmpathyChatroom * empathy_chatroom_manager_find (EmpathyChatroomManager *manager, - EmpathyAccount *account, - const gchar *room); + TpAccount *account, + const gchar *room); GList * empathy_chatroom_manager_get_chatrooms (EmpathyChatroomManager *manager, - EmpathyAccount *account); + TpAccount *account); guint empathy_chatroom_manager_get_count (EmpathyChatroomManager *manager, - EmpathyAccount *account); + TpAccount *account); void empathy_chatroom_manager_observe (EmpathyChatroomManager *manager, EmpathyDispatcher *dispatcher); diff --git a/libempathy/empathy-chatroom.c b/libempathy/empathy-chatroom.c index 33df9a3d6..5d43a3ec1 100644 --- a/libempathy/empathy-chatroom.c +++ b/libempathy/empathy-chatroom.c @@ -31,7 +31,7 @@ #define GET_PRIV(obj) EMPATHY_GET_PRIV (obj, EmpathyChatroom) typedef struct { - EmpathyAccount *account; + TpAccount *account; gchar *room; gchar *name; gboolean auto_connect; @@ -84,7 +84,7 @@ empathy_chatroom_class_init (EmpathyChatroomClass *klass) g_param_spec_object ("account", "Chatroom Account", "The account associated with an chatroom", - EMPATHY_TYPE_ACCOUNT, + TP_TYPE_ACCOUNT, G_PARAM_READWRITE)); g_object_class_install_property (object_class, @@ -312,7 +312,7 @@ chatroom_set_property (GObject *object, } EmpathyChatroom * -empathy_chatroom_new (EmpathyAccount *account) +empathy_chatroom_new (TpAccount *account) { return g_object_new (EMPATHY_TYPE_CHATROOM, "account", account, @@ -320,7 +320,7 @@ empathy_chatroom_new (EmpathyAccount *account) } EmpathyChatroom * -empathy_chatroom_new_full (EmpathyAccount *account, +empathy_chatroom_new_full (TpAccount *account, const gchar *room, const gchar *name, gboolean auto_connect) @@ -335,7 +335,7 @@ empathy_chatroom_new_full (EmpathyAccount *account, NULL); } -EmpathyAccount * +TpAccount * empathy_chatroom_get_account (EmpathyChatroom *chatroom) { EmpathyChatroomPriv *priv; @@ -348,7 +348,7 @@ empathy_chatroom_get_account (EmpathyChatroom *chatroom) void empathy_chatroom_set_account (EmpathyChatroom *chatroom, - EmpathyAccount *account) + TpAccount *account) { EmpathyChatroomPriv *priv; @@ -466,8 +466,8 @@ gboolean empathy_chatroom_equal (gconstpointer v1, gconstpointer v2) { - EmpathyAccount *account_a; - EmpathyAccount *account_b; + TpAccount *account_a; + TpAccount *account_b; const gchar *room_a; const gchar *room_b; diff --git a/libempathy/empathy-chatroom.h b/libempathy/empathy-chatroom.h index c18c27449..3048aded7 100644 --- a/libempathy/empathy-chatroom.h +++ b/libempathy/empathy-chatroom.h @@ -24,7 +24,8 @@ #include <glib-object.h> -#include <libempathy/empathy-account.h> +#include <telepathy-glib/account.h> + #include <libempathy/empathy-tp-chat.h> G_BEGIN_DECLS @@ -51,14 +52,14 @@ struct _EmpathyChatroomClass { }; GType empathy_chatroom_get_type (void) G_GNUC_CONST; -EmpathyChatroom *empathy_chatroom_new (EmpathyAccount *account); -EmpathyChatroom *empathy_chatroom_new_full (EmpathyAccount *account, +EmpathyChatroom *empathy_chatroom_new (TpAccount *account); +EmpathyChatroom *empathy_chatroom_new_full (TpAccount *account, const gchar *room, const gchar *name, gboolean auto_connect); -EmpathyAccount * empathy_chatroom_get_account (EmpathyChatroom *chatroom); +TpAccount * empathy_chatroom_get_account (EmpathyChatroom *chatroom); void empathy_chatroom_set_account (EmpathyChatroom *chatroom, - EmpathyAccount *account); + TpAccount *account); const gchar * empathy_chatroom_get_room (EmpathyChatroom *chatroom); void empathy_chatroom_set_room (EmpathyChatroom *chatroom, const gchar *room); diff --git a/libempathy/empathy-contact-manager.c b/libempathy/empathy-contact-manager.c index 302fad3c5..53ccfbd63 100644 --- a/libempathy/empathy-contact-manager.c +++ b/libempathy/empathy-contact-manager.c @@ -23,10 +23,10 @@ #include <string.h> +#include <telepathy-glib/account-manager.h> #include <telepathy-glib/enums.h> #include "empathy-contact-manager.h" -#include "empathy-account-manager.h" #include "empathy-contact-monitor.h" #include "empathy-contact-list.h" #include "empathy-utils.h" @@ -37,7 +37,7 @@ #define GET_PRIV(obj) EMPATHY_GET_PRIV (obj, EmpathyContactManager) typedef struct { GHashTable *lists; - EmpathyAccountManager *account_manager; + TpAccountManager *account_manager; EmpathyContactMonitor *contact_monitor; } EmpathyContactManagerPriv; @@ -132,14 +132,21 @@ contact_manager_disconnect_foreach (gpointer key, } static void -contact_manager_new_connection_cb (EmpathyAccountManager *account_manager, - TpConnection *connection, +contact_manager_status_changed_cb (TpAccount *account, + guint old_status, + guint new_status, + guint reason, + gchar *dbus_error_name, + GHashTable *details, EmpathyContactManager *self) { EmpathyContactManagerPriv *priv = GET_PRIV (self); EmpathyTpContactList *list; + TpConnection *connection; + + connection = tp_account_get_connection (account); - if (g_hash_table_lookup (priv->lists, connection)) { + if (connection == NULL || g_hash_table_lookup (priv->lists, connection)) { return; } @@ -174,9 +181,6 @@ contact_manager_finalize (GObject *object) object); g_hash_table_destroy (priv->lists); - g_signal_handlers_disconnect_by_func (priv->account_manager, - contact_manager_new_connection_cb, - object); g_object_unref (priv->account_manager); if (priv->contact_monitor) { @@ -233,9 +237,42 @@ empathy_contact_manager_class_init (EmpathyContactManagerClass *klass) } static void +account_manager_prepared_cb (GObject *source_object, + GAsyncResult *result, + gpointer user_data) +{ + GList *accounts, *l; + EmpathyContactManager *manager = user_data; + TpAccountManager *account_manager = TP_ACCOUNT_MANAGER (source_object); + GError *error = NULL; + + if (!tp_account_manager_prepare_finish (account_manager, result, &error)) { + DEBUG ("Failed to prepare account manager: %s", error->message); + g_error_free (error); + return; + } + + accounts = tp_account_manager_get_valid_accounts (account_manager); + + for (l = accounts; l != NULL; l = l->next) { + TpAccount *account = l->data; + TpConnection *conn = tp_account_get_connection (account); + + if (conn != NULL) { + contact_manager_status_changed_cb (account, 0, 0, 0, + NULL, NULL, manager); + } + + empathy_signal_connect_weak (account, "status-changed", + G_CALLBACK (contact_manager_status_changed_cb), + G_OBJECT (manager)); + } + g_list_free (accounts); +} + +static void empathy_contact_manager_init (EmpathyContactManager *manager) { - GList *connections, *l; EmpathyContactManagerPriv *priv = G_TYPE_INSTANCE_GET_PRIVATE (manager, EMPATHY_TYPE_CONTACT_MANAGER, EmpathyContactManagerPriv); @@ -244,21 +281,11 @@ empathy_contact_manager_init (EmpathyContactManager *manager) empathy_proxy_equal, (GDestroyNotify) g_object_unref, (GDestroyNotify) g_object_unref); - priv->account_manager = empathy_account_manager_dup_singleton (); + priv->account_manager = tp_account_manager_dup (); priv->contact_monitor = NULL; - g_signal_connect (priv->account_manager, "new-connection", - G_CALLBACK (contact_manager_new_connection_cb), - manager); - - /* Get ContactList for existing connections */ - connections = empathy_account_manager_dup_connections (priv->account_manager); - for (l = connections; l; l = l->next) { - contact_manager_new_connection_cb (priv->account_manager, - l->data, manager); - g_object_unref (l->data); - } - g_list_free (connections); + tp_account_manager_prepare_async (priv->account_manager, NULL, + account_manager_prepared_cb, manager); } EmpathyContactManager * diff --git a/libempathy/empathy-contact.c b/libempathy/empathy-contact.c index 83ffd0780..a440ef23b 100644 --- a/libempathy/empathy-contact.c +++ b/libempathy/empathy-contact.c @@ -25,10 +25,10 @@ #include <glib/gi18n-lib.h> +#include <telepathy-glib/account-manager.h> #include <telepathy-glib/util.h> #include "empathy-contact.h" -#include "empathy-account-manager.h" #include "empathy-utils.h" #include "empathy-enum-types.h" #include "empathy-marshal.h" @@ -39,7 +39,7 @@ #define GET_PRIV(obj) EMPATHY_GET_PRIV (obj, EmpathyContact) typedef struct { TpContact *tp_contact; - EmpathyAccount *account; + TpAccount *account; gchar *id; gchar *name; EmpathyAvatar *avatar; @@ -159,7 +159,7 @@ empathy_contact_class_init (EmpathyContactClass *class) g_param_spec_object ("account", "The account", "The account associated with the contact", - EMPATHY_TYPE_ACCOUNT, + TP_TYPE_ACCOUNT, G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (object_class, @@ -409,7 +409,7 @@ empathy_contact_new (TpContact *tp_contact) } EmpathyContact * -empathy_contact_new_for_log (EmpathyAccount *account, +empathy_contact_new_for_log (TpAccount *account, const gchar *id, const gchar *name, gboolean is_user) @@ -554,7 +554,7 @@ empathy_contact_set_avatar (EmpathyContact *contact, g_object_notify (G_OBJECT (contact), "avatar"); } -EmpathyAccount * +TpAccount * empathy_contact_get_account (EmpathyContact *contact) { EmpathyContactPriv *priv; @@ -565,16 +565,12 @@ empathy_contact_get_account (EmpathyContact *contact) if (priv->account == NULL && priv->tp_contact != NULL) { - EmpathyAccountManager *manager; TpConnection *connection; /* FIXME: This assume the account manager already exists */ - manager = empathy_account_manager_dup_singleton (); connection = tp_contact_get_connection (priv->tp_contact); - priv->account = empathy_account_manager_get_account_for_connection ( - manager, connection); - g_object_ref (priv->account); - g_object_unref (manager); + priv->account = + g_object_ref (empathy_get_account_for_connection (connection)); } return priv->account; @@ -855,7 +851,7 @@ static gchar * contact_get_avatar_filename (EmpathyContact *contact, const gchar *token) { - EmpathyAccount *account; + TpAccount *account; gchar *avatar_path; gchar *avatar_file; gchar *token_escaped; @@ -869,8 +865,8 @@ contact_get_avatar_filename (EmpathyContact *contact, avatar_path = g_build_filename (g_get_user_cache_dir (), "telepathy", "avatars", - empathy_account_get_connection_manager (account), - empathy_account_get_protocol (account), + tp_account_get_connection_manager (account), + tp_account_get_protocol (account), NULL); g_mkdir_with_parents (avatar_path, 0700); diff --git a/libempathy/empathy-contact.h b/libempathy/empathy-contact.h index 4e9c98756..d5525818b 100644 --- a/libempathy/empathy-contact.h +++ b/libempathy/empathy-contact.h @@ -25,7 +25,7 @@ #include <glib-object.h> #include <telepathy-glib/contact.h> -#include <libempathy/empathy-account.h> +#include <telepathy-glib/account.h> G_BEGIN_DECLS @@ -70,7 +70,7 @@ typedef enum { GType empathy_contact_get_type (void) G_GNUC_CONST; EmpathyContact * empathy_contact_new (TpContact *tp_contact); -EmpathyContact * empathy_contact_new_for_log (EmpathyAccount *account, +EmpathyContact * empathy_contact_new_for_log (TpAccount *account, const gchar *id, const gchar *name, gboolean is_user); TpContact * empathy_contact_get_tp_contact (EmpathyContact *contact); const gchar * empathy_contact_get_id (EmpathyContact *contact); @@ -80,7 +80,7 @@ void empathy_contact_set_name (EmpathyContact *contact, const gchar *name); EmpathyAvatar * empathy_contact_get_avatar (EmpathyContact *contact); void empathy_contact_set_avatar (EmpathyContact *contact, EmpathyAvatar *avatar); -EmpathyAccount * empathy_contact_get_account (EmpathyContact *contact); +TpAccount * empathy_contact_get_account (EmpathyContact *contact); TpConnection * empathy_contact_get_connection (EmpathyContact *contact); TpConnectionPresenceType empathy_contact_get_presence (EmpathyContact *contact); void empathy_contact_set_presence (EmpathyContact *contact, diff --git a/libempathy/empathy-dispatcher.c b/libempathy/empathy-dispatcher.c index eb43bc10e..40045cdb1 100644 --- a/libempathy/empathy-dispatcher.c +++ b/libempathy/empathy-dispatcher.c @@ -28,6 +28,7 @@ #include <glib/gi18n-lib.h> +#include <telepathy-glib/account-manager.h> #include <telepathy-glib/enums.h> #include <telepathy-glib/connection.h> #include <telepathy-glib/util.h> @@ -45,7 +46,6 @@ #include "empathy-handler.h" #include "empathy-utils.h" #include "empathy-tube-handler.h" -#include "empathy-account-manager.h" #include "empathy-tp-contact-factory.h" #include "empathy-chatroom-manager.h" #include "empathy-utils.h" @@ -58,7 +58,7 @@ typedef struct { gboolean dispose_has_run; - EmpathyAccountManager *account_manager; + TpAccountManager *account_manager; /* connection to connection data mapping */ GHashTable *connections; GHashTable *outstanding_classes_requests; @@ -890,11 +890,18 @@ dispatcher_init_connection_if_needed (EmpathyDispatcher *self, } static void -dispatcher_new_connection_cb (EmpathyAccountManager *manager, - TpConnection *connection, +dispatcher_status_changed_cb (TpAccount *account, + guint old_status, + guint new_status, + guint reason, + gchar *dbus_error_name, + GHashTable *details, EmpathyDispatcher *self) { - dispatcher_init_connection_if_needed (self, connection); + TpConnection *conn = tp_account_get_connection (account); + + if (conn != NULL) + dispatcher_init_connection_if_needed (self, conn); } static void @@ -993,9 +1000,6 @@ dispatcher_finalize (GObject *object) g_hash_table_destroy (priv->request_channel_class_async_ids); } - g_signal_handlers_disconnect_by_func (priv->account_manager, - dispatcher_new_connection_cb, object); - for (l = priv->channels; l; l = l->next) { g_signal_handlers_disconnect_by_func (l->data, @@ -1111,18 +1115,46 @@ empathy_dispatcher_class_init (EmpathyDispatcherClass *klass) } static void +account_manager_prepared_cb (GObject *source_object, + GAsyncResult *result, + gpointer user_data) +{ + GList *accounts, *l; + EmpathyDispatcher *self = user_data; + TpAccountManager *account_manager = TP_ACCOUNT_MANAGER (source_object); + GError *error = NULL; + + if (!tp_account_manager_prepare_finish (account_manager, result, &error)) + { + DEBUG ("Failed to prepare account manager: %s", error->message); + g_error_free (error); + return; + } + + accounts = tp_account_manager_get_valid_accounts (account_manager); + for (l = accounts; l; l = l->next) + { + TpAccount *a = l->data; + TpConnection *conn = tp_account_get_connection (a); + + if (conn != NULL) + dispatcher_status_changed_cb (a, 0, 0, 0, NULL, NULL, self); + + empathy_signal_connect_weak (a, "status-changed", + G_CALLBACK (dispatcher_status_changed_cb), + G_OBJECT (self)); + } + g_list_free (accounts); +} + +static void empathy_dispatcher_init (EmpathyDispatcher *self) { - GList *connections, *l; EmpathyDispatcherPriv *priv = G_TYPE_INSTANCE_GET_PRIVATE (self, EMPATHY_TYPE_DISPATCHER, EmpathyDispatcherPriv); self->priv = priv; - priv->account_manager = empathy_account_manager_dup_singleton (); - - g_signal_connect (priv->account_manager, "new-connection", - G_CALLBACK (dispatcher_new_connection_cb), - self); + priv->account_manager = tp_account_manager_dup (); priv->connections = g_hash_table_new_full (g_direct_hash, g_direct_equal, g_object_unref, (GDestroyNotify) free_connection_data); @@ -1132,15 +1164,8 @@ empathy_dispatcher_init (EmpathyDispatcher *self) priv->channels = NULL; - connections = empathy_account_manager_dup_connections ( - priv->account_manager); - for (l = connections; l; l = l->next) - { - dispatcher_new_connection_cb (priv->account_manager, l->data, - self); - g_object_unref (l->data); - } - g_list_free (connections); + tp_account_manager_prepare_async (priv->account_manager, NULL, + account_manager_prepared_cb, self); priv->request_channel_class_async_ids = g_hash_table_new (g_direct_hash, g_direct_equal); @@ -1956,15 +1981,16 @@ empathy_dispatcher_handle_channels (EmpathyHandler *handler, EmpathyDispatcher *self = EMPATHY_DISPATCHER (user_data); EmpathyDispatcherPriv *priv = GET_PRIV (self); guint i; - EmpathyAccount *account; + TpAccount *account; TpConnection *connection; - account = empathy_account_manager_ensure_account (priv->account_manager, + /* FIXME: should probably find out whether the account manager is prepared + * before ensuring. See bug #600111. */ + account = tp_account_manager_ensure_account (priv->account_manager, account_path); g_assert (account != NULL); - connection = empathy_account_get_connection_for_path (account, - connection_path); + connection = tp_account_ensure_connection (account, connection_path); if (connection == NULL) { g_set_error_literal (error, TP_ERRORS, TP_ERROR_INVALID_ARGUMENT, diff --git a/libempathy/empathy-idle.c b/libempathy/empathy-idle.c index cc6ca62f4..8a0fcd88d 100644 --- a/libempathy/empathy-idle.c +++ b/libempathy/empathy-idle.c @@ -26,10 +26,10 @@ #include <glib/gi18n-lib.h> #include <dbus/dbus-glib.h> +#include <telepathy-glib/account-manager.h> #include <telepathy-glib/dbus.h> #include <telepathy-glib/util.h> -#include "empathy-account-manager.h" #include "empathy-idle.h" #include "empathy-utils.h" #include "empathy-connectivity.h" @@ -40,6 +40,10 @@ /* Number of seconds before entering extended autoaway. */ #define EXT_AWAY_TIME (30*60) +/* Number of seconds to consider an account in the "just connected" state + * for. */ +#define ACCOUNT_IS_JUST_CONNECTED_SECONDS 10 + #define GET_PRIV(obj) EMPATHY_GET_PRIV (obj, EmpathyIdle) typedef struct { DBusGProxy *gs_proxy; @@ -58,7 +62,14 @@ typedef struct { gboolean is_idle; guint ext_away_timeout; - EmpathyAccountManager *manager; + TpAccountManager *manager; + + /* pointer to a TpAccount --> glong of time of connection */ + GHashTable *connect_times; + + TpConnectionPresenceType requested_presence_type; + gchar *requested_status_message; + } EmpathyIdlePriv; typedef enum { @@ -81,8 +92,20 @@ G_DEFINE_TYPE (EmpathyIdle, empathy_idle, G_TYPE_OBJECT); static EmpathyIdle * idle_singleton = NULL; +static const gchar *presence_type_to_status[NUM_TP_CONNECTION_PRESENCE_TYPES] = { + NULL, + "offline", + "available", + "away", + "xa", + "hidden", + "busy", + NULL, + NULL, +}; + static void -idle_presence_changed_cb (EmpathyAccountManager *manager, +idle_presence_changed_cb (TpAccountManager *manager, TpConnectionPresenceType state, gchar *status, gchar *status_message, @@ -279,6 +302,7 @@ idle_finalize (GObject *object) priv = GET_PRIV (object); g_free (priv->status); + g_free (priv->requested_status_message); if (priv->gs_proxy) { g_object_unref (priv->gs_proxy); @@ -290,6 +314,9 @@ idle_finalize (GObject *object) g_object_unref (priv->connectivity); + g_hash_table_destroy (priv->connect_times); + priv->connect_times = NULL; + idle_ext_away_stop (EMPATHY_IDLE (object)); } @@ -421,22 +448,60 @@ empathy_idle_class_init (EmpathyIdleClass *klass) } static void -account_manager_ready_cb (EmpathyAccountManager *account_manager, - GParamSpec *pspec, - EmpathyIdle *idle) +account_status_changed_cb (TpAccount *account, + guint old_status, + guint new_status, + guint reason, + gchar *dbus_error_name, + GHashTable *details, + gpointer user_data) { - EmpathyIdlePriv *priv; + EmpathyIdle *idle = EMPATHY_IDLE (user_data); + EmpathyIdlePriv *priv = GET_PRIV (idle); + GTimeVal val; + + if (new_status == TP_CONNECTION_STATUS_CONNECTED) { + g_get_current_time (&val); + g_hash_table_insert (priv->connect_times, account, + GINT_TO_POINTER (val.tv_sec)); + } else if (new_status == TP_CONNECTION_STATUS_DISCONNECTED) { + g_hash_table_remove (priv->connect_times, account); + } +} + +static void +account_manager_ready_cb (GObject *source_object, + GAsyncResult *result, + gpointer user_data) +{ + EmpathyIdle *idle = EMPATHY_IDLE (user_data); + TpAccountManager *account_manager = TP_ACCOUNT_MANAGER (source_object); + EmpathyIdlePriv *priv = GET_PRIV (idle); TpConnectionPresenceType state; gchar *status, *status_message; + GList *accounts, *l; + GError *error = NULL; - priv = GET_PRIV (idle); + if (!tp_account_manager_prepare_finish (account_manager, result, &error)) { + DEBUG ("Failed to prepare account manager: %s", error->message); + g_error_free (error); + return; + } - state = empathy_account_manager_get_global_presence (priv->manager, + state = tp_account_manager_get_most_available_presence (priv->manager, &status, &status_message); idle_presence_changed_cb (account_manager, state, status, status_message, idle); + accounts = tp_account_manager_get_valid_accounts (priv->manager); + for (l = accounts; l != NULL; l = l->next) { + empathy_signal_connect_weak (l->data, "status-changed", + G_CALLBACK (account_status_changed_cb), + G_OBJECT (idle)); + } + g_list_free (accounts); + g_free (status); g_free (status_message); } @@ -450,18 +515,12 @@ empathy_idle_init (EmpathyIdle *idle) idle->priv = priv; priv->is_idle = FALSE; - priv->manager = empathy_account_manager_dup_singleton (); - - if (empathy_account_manager_is_ready (priv->manager)) { - priv->state = empathy_account_manager_get_global_presence (priv->manager, - NULL, &priv->status); - } else { - g_signal_connect (priv->manager, "notify::ready", - G_CALLBACK (account_manager_ready_cb), idle); - } + priv->manager = tp_account_manager_dup (); + tp_account_manager_prepare_async (priv->manager, NULL, + account_manager_ready_cb, idle); - g_signal_connect (priv->manager, "global-presence-changed", + g_signal_connect (priv->manager, "most-available-presence-changed", G_CALLBACK (idle_presence_changed_cb), idle); priv->gs_proxy = dbus_g_proxy_new_for_name (tp_get_bus (), @@ -481,6 +540,8 @@ empathy_idle_init (EmpathyIdle *idle) priv->connectivity = empathy_connectivity_dup_singleton (); priv->state_change_signal_id = g_signal_connect (priv->connectivity, "state-change", G_CALLBACK (idle_state_change_cb), idle); + + priv->connect_times = g_hash_table_new (g_direct_hash, g_direct_equal); } EmpathyIdle * @@ -567,26 +628,21 @@ empathy_idle_do_set_presence (EmpathyIdle *idle, const gchar *status_message) { EmpathyIdlePriv *priv = GET_PRIV (idle); - const gchar *statuses[NUM_TP_CONNECTION_PRESENCE_TYPES] = { - NULL, - "offline", - "available", - "away", - "xa", - "hidden", - "busy", - NULL, - NULL, - }; const gchar *status; g_assert (status_type > 0 && status_type < NUM_TP_CONNECTION_PRESENCE_TYPES); - status = statuses[status_type]; + status = presence_type_to_status[status_type]; g_return_if_fail (status != NULL); - empathy_account_manager_request_global_presence (priv->manager, + /* We possibly should be sure that the account manager is prepared, but + * sometimes this isn't possible, like when exiting. In other words, + * we need a callback to empathy_idle_set_presence to be sure the + * presence is set on all accounts successfully. + * However, in practice, this is fine as we've already prepared the + * account manager here in _init. */ + tp_account_manager_set_all_requested_presences (priv->manager, status_type, status, status_message); } @@ -602,6 +658,10 @@ empathy_idle_set_presence (EmpathyIdle *idle, DEBUG ("Changing presence to %s (%d)", status, state); + g_free (priv->requested_status_message); + priv->requested_presence_type = state; + priv->requested_status_message = g_strdup (status); + /* Do not set translated default messages */ default_status = empathy_presence_get_default_message (state); if (!tp_strdiff (status, default_status)) { @@ -645,3 +705,50 @@ empathy_idle_set_auto_away (EmpathyIdle *idle, g_object_notify (G_OBJECT (idle), "auto-away"); } +TpConnectionPresenceType +empathy_idle_get_requested_presence (EmpathyIdle *idle, + gchar **status, + gchar **status_message) +{ + EmpathyIdlePriv *priv = GET_PRIV (idle); + + if (status != NULL) { + *status = g_strdup (presence_type_to_status[priv->requested_presence_type]); + } + + if (status_message != NULL) { + *status_message = g_strdup (priv->requested_status_message); + } + + return priv->requested_presence_type; +} + +/* This function returns %TRUE if EmpathyIdle considers the account + * @account as having just connected recently. Otherwise, it returns + * %FALSE. In doubt, %FALSE is returned. */ +gboolean +empathy_idle_account_is_just_connected (EmpathyIdle *idle, + TpAccount *account) +{ + EmpathyIdlePriv *priv = GET_PRIV (idle); + GTimeVal val; + gpointer ptr; + glong t; + + if (tp_account_get_connection_status (account, NULL) + != TP_CONNECTION_STATUS_CONNECTED) { + return FALSE; + } + + ptr = g_hash_table_lookup (priv->connect_times, account); + + if (ptr == NULL) { + return FALSE; + } + + t = GPOINTER_TO_INT (ptr); + + g_get_current_time (&val); + + return (val.tv_sec - t) < ACCOUNT_IS_JUST_CONNECTED_SECONDS; +} diff --git a/libempathy/empathy-idle.h b/libempathy/empathy-idle.h index 47dcfee23..1a8c313bc 100644 --- a/libempathy/empathy-idle.h +++ b/libempathy/empathy-idle.h @@ -65,6 +65,13 @@ gboolean empathy_idle_get_auto_away (EmpathyIdle *idle); void empathy_idle_set_auto_away (EmpathyIdle *idle, gboolean auto_away); +TpConnectionPresenceType empathy_idle_get_requested_presence (EmpathyIdle *idle, + gchar **status, + gchar **status_message); + +gboolean empathy_idle_account_is_just_connected (EmpathyIdle *idle, + TpAccount *account); + G_END_DECLS #endif /* __EMPATHY_IDLE_H__ */ diff --git a/libempathy/empathy-log-manager.c b/libempathy/empathy-log-manager.c index 309b3b60f..5a57f0c74 100644 --- a/libempathy/empathy-log-manager.c +++ b/libempathy/empathy-log-manager.c @@ -158,7 +158,7 @@ empathy_log_manager_add_message (EmpathyLogManager *manager, gboolean empathy_log_manager_exists (EmpathyLogManager *manager, - EmpathyAccount *account, + TpAccount *account, const gchar *chat_id, gboolean chatroom) { @@ -182,7 +182,7 @@ empathy_log_manager_exists (EmpathyLogManager *manager, GList * empathy_log_manager_get_dates (EmpathyLogManager *manager, - EmpathyAccount *account, + TpAccount *account, const gchar *chat_id, gboolean chatroom) { @@ -218,7 +218,7 @@ empathy_log_manager_get_dates (EmpathyLogManager *manager, GList * empathy_log_manager_get_messages_for_date (EmpathyLogManager *manager, - EmpathyAccount *account, + TpAccount *account, const gchar *chat_id, gboolean chatroom, const gchar *date) @@ -259,7 +259,7 @@ log_manager_message_date_cmp (gconstpointer a, GList * empathy_log_manager_get_filtered_messages (EmpathyLogManager *manager, - EmpathyAccount *account, + TpAccount *account, const gchar *chat_id, gboolean chatroom, guint num_messages, @@ -319,7 +319,7 @@ empathy_log_manager_get_filtered_messages (EmpathyLogManager *manager, GList * empathy_log_manager_get_chats (EmpathyLogManager *manager, - EmpathyAccount *account) + TpAccount *account) { GList *l, *out = NULL; EmpathyLogManagerPriv *priv; diff --git a/libempathy/empathy-log-manager.h b/libempathy/empathy-log-manager.h index a67f6e8dd..25f1b5fcd 100644 --- a/libempathy/empathy-log-manager.h +++ b/libempathy/empathy-log-manager.h @@ -63,7 +63,7 @@ struct _EmpathyLogManagerClass struct _EmpathyLogSearchHit { - EmpathyAccount *account; + TpAccount *account; gchar *chat_id; gboolean is_chatroom; gchar *filename; @@ -79,17 +79,17 @@ gboolean empathy_log_manager_add_message (EmpathyLogManager *manager, const gchar *chat_id, gboolean chatroom, EmpathyMessage *message, GError **error); gboolean empathy_log_manager_exists (EmpathyLogManager *manager, - EmpathyAccount *account, const gchar *chat_id, gboolean chatroom); + TpAccount *account, const gchar *chat_id, gboolean chatroom); GList *empathy_log_manager_get_dates (EmpathyLogManager *manager, - EmpathyAccount *account, const gchar *chat_id, gboolean chatroom); + TpAccount *account, const gchar *chat_id, gboolean chatroom); GList *empathy_log_manager_get_messages_for_date (EmpathyLogManager *manager, - EmpathyAccount *account, const gchar *chat_id, gboolean chatroom, + TpAccount *account, const gchar *chat_id, gboolean chatroom, const gchar *date); GList *empathy_log_manager_get_filtered_messages (EmpathyLogManager *manager, - EmpathyAccount *account, const gchar *chat_id, gboolean chatroom, + TpAccount *account, const gchar *chat_id, gboolean chatroom, guint num_messages, EmpathyLogMessageFilter filter, gpointer user_data); GList *empathy_log_manager_get_chats (EmpathyLogManager *manager, - EmpathyAccount *account); + TpAccount *account); GList *empathy_log_manager_search_new (EmpathyLogManager *manager, const gchar *text); void empathy_log_manager_search_free (GList *hits); diff --git a/libempathy/empathy-log-store-empathy.c b/libempathy/empathy-log-store-empathy.c index 9771a9f28..8a25df7bc 100644 --- a/libempathy/empathy-log-store-empathy.c +++ b/libempathy/empathy-log-store-empathy.c @@ -29,13 +29,13 @@ #include <stdlib.h> #include <glib/gstdio.h> +#include <telepathy-glib/account-manager.h> #include <telepathy-glib/util.h> #include <telepathy-glib/defs.h> #include "empathy-log-store.h" #include "empathy-log-store-empathy.h" #include "empathy-log-manager.h" -#include "empathy-account-manager.h" #include "empathy-contact.h" #include "empathy-time.h" #include "empathy-utils.h" @@ -63,7 +63,7 @@ typedef struct { gchar *basedir; gchar *name; - EmpathyAccountManager *account_manager; + TpAccountManager *account_manager; } EmpathyLogStoreEmpathyPriv; static void log_store_iface_init (gpointer g_iface,gpointer iface_data); @@ -105,15 +105,15 @@ empathy_log_store_empathy_init (EmpathyLogStoreEmpathy *self) PACKAGE_NAME, "logs", NULL); priv->name = g_strdup ("Empathy"); - priv->account_manager = empathy_account_manager_dup_singleton (); + priv->account_manager = tp_account_manager_dup (); } static gchar * -log_store_account_to_dirname (EmpathyAccount *account) +log_store_account_to_dirname (TpAccount *account) { const gchar *name; - name = empathy_account_get_unique_name (account); + name = tp_proxy_get_object_path (account); if (g_str_has_prefix (name, TP_ACCOUNT_OBJECT_PATH_BASE)) name += strlen (TP_ACCOUNT_OBJECT_PATH_BASE); @@ -123,7 +123,7 @@ log_store_account_to_dirname (EmpathyAccount *account) static gchar * log_store_empathy_get_dir (EmpathyLogStore *self, - EmpathyAccount *account, + TpAccount *account, const gchar *chat_id, gboolean chatroom) { @@ -176,7 +176,7 @@ log_store_empathy_get_timestamp_from_message (EmpathyMessage *message) static gchar * log_store_empathy_get_filename (EmpathyLogStore *self, - EmpathyAccount *account, + TpAccount *account, const gchar *chat_id, gboolean chatroom) { @@ -202,7 +202,7 @@ log_store_empathy_add_message (EmpathyLogStore *self, GError **error) { FILE *file; - EmpathyAccount *account; + TpAccount *account; EmpathyContact *sender; const gchar *body_str; const gchar *str; @@ -289,7 +289,7 @@ log_store_empathy_add_message (EmpathyLogStore *self, static gboolean log_store_empathy_exists (EmpathyLogStore *self, - EmpathyAccount *account, + TpAccount *account, const gchar *chat_id, gboolean chatroom) { @@ -305,7 +305,7 @@ log_store_empathy_exists (EmpathyLogStore *self, static GList * log_store_empathy_get_dates (EmpathyLogStore *self, - EmpathyAccount *account, + TpAccount *account, const gchar *chat_id, gboolean chatroom) { @@ -357,7 +357,7 @@ log_store_empathy_get_dates (EmpathyLogStore *self, static gchar * log_store_empathy_get_filename_for_date (EmpathyLogStore *self, - EmpathyAccount *account, + TpAccount *account, const gchar *chat_id, gboolean chatroom, const gchar *date) @@ -406,11 +406,13 @@ log_store_empathy_search_hit_new (EmpathyLogStore *self, else account_name = strv[len-3]; - accounts = empathy_account_manager_dup_accounts (priv->account_manager); + /* FIXME: This assumes the account manager is prepared, but the + * synchronous API forces this. See bug #599189. */ + accounts = tp_account_manager_get_valid_accounts (priv->account_manager); for (l = accounts; l != NULL; l = g_list_next (l)) { - EmpathyAccount *account = EMPATHY_ACCOUNT (l->data); + TpAccount *account = TP_ACCOUNT (l->data); gchar *name; name = log_store_account_to_dirname (account); @@ -434,7 +436,7 @@ log_store_empathy_search_hit_new (EmpathyLogStore *self, static GList * log_store_empathy_get_messages_for_file (EmpathyLogStore *self, - EmpathyAccount *account, + TpAccount *account, const gchar *filename) { GList *messages = NULL; @@ -703,7 +705,7 @@ log_store_empathy_get_chats_for_dir (EmpathyLogStore *self, static GList * log_store_empathy_get_messages_for_date (EmpathyLogStore *self, - EmpathyAccount *account, + TpAccount *account, const gchar *chat_id, gboolean chatroom, const gchar *date) @@ -726,7 +728,7 @@ log_store_empathy_get_messages_for_date (EmpathyLogStore *self, static GList * log_store_empathy_get_chats (EmpathyLogStore *self, - EmpathyAccount *account) + TpAccount *account) { gchar *dir; GList *hits; @@ -753,7 +755,7 @@ log_store_empathy_get_name (EmpathyLogStore *self) static GList * log_store_empathy_get_filtered_messages (EmpathyLogStore *self, - EmpathyAccount *account, + TpAccount *account, const gchar *chat_id, gboolean chatroom, guint num_messages, diff --git a/libempathy/empathy-log-store.c b/libempathy/empathy-log-store.c index f136f7910..512c4c09b 100644 --- a/libempathy/empathy-log-store.c +++ b/libempathy/empathy-log-store.c @@ -55,7 +55,7 @@ empathy_log_store_get_name (EmpathyLogStore *self) gboolean empathy_log_store_exists (EmpathyLogStore *self, - EmpathyAccount *account, + TpAccount *account, const gchar *chat_id, gboolean chatroom) { @@ -84,7 +84,7 @@ empathy_log_store_add_message (EmpathyLogStore *self, GList * empathy_log_store_get_dates (EmpathyLogStore *self, - EmpathyAccount *account, + TpAccount *account, const gchar *chat_id, gboolean chatroom) { @@ -97,7 +97,7 @@ empathy_log_store_get_dates (EmpathyLogStore *self, GList * empathy_log_store_get_messages_for_date (EmpathyLogStore *self, - EmpathyAccount *account, + TpAccount *account, const gchar *chat_id, gboolean chatroom, const gchar *date) @@ -111,7 +111,7 @@ empathy_log_store_get_messages_for_date (EmpathyLogStore *self, GList * empathy_log_store_get_last_messages (EmpathyLogStore *self, - EmpathyAccount *account, + TpAccount *account, const gchar *chat_id, gboolean chatroom) { @@ -124,7 +124,7 @@ empathy_log_store_get_last_messages (EmpathyLogStore *self, GList * empathy_log_store_get_chats (EmpathyLogStore *self, - EmpathyAccount *account) + TpAccount *account) { if (!EMPATHY_LOG_STORE_GET_INTERFACE (self)->get_chats) return NULL; @@ -157,7 +157,7 @@ empathy_log_store_ack_message (EmpathyLogStore *self, GList * empathy_log_store_get_filtered_messages (EmpathyLogStore *self, - EmpathyAccount *account, + TpAccount *account, const gchar *chat_id, gboolean chatroom, guint num_messages, diff --git a/libempathy/empathy-log-store.h b/libempathy/empathy-log-store.h index 5b6a87875..94bc87386 100644 --- a/libempathy/empathy-log-store.h +++ b/libempathy/empathy-log-store.h @@ -25,7 +25,7 @@ #include <glib-object.h> -#include <libempathy/empathy-account.h> +#include <telepathy-glib/account.h> #include "empathy-message.h" #include "empathy-log-manager.h" @@ -50,23 +50,23 @@ struct _EmpathyLogStoreInterface GTypeInterface parent; const gchar * (*get_name) (EmpathyLogStore *self); - gboolean (*exists) (EmpathyLogStore *self, EmpathyAccount *account, + gboolean (*exists) (EmpathyLogStore *self, TpAccount *account, const gchar *chat_id, gboolean chatroom); gboolean (*add_message) (EmpathyLogStore *self, const gchar *chat_id, gboolean chatroom, EmpathyMessage *message, GError **error); - GList * (*get_dates) (EmpathyLogStore *self, EmpathyAccount *account, + GList * (*get_dates) (EmpathyLogStore *self, TpAccount *account, const gchar *chat_id, gboolean chatroom); GList * (*get_messages_for_date) (EmpathyLogStore *self, - EmpathyAccount *account, const gchar *chat_id, gboolean chatroom, + TpAccount *account, const gchar *chat_id, gboolean chatroom, const gchar *date); - GList * (*get_last_messages) (EmpathyLogStore *self, EmpathyAccount *account, + GList * (*get_last_messages) (EmpathyLogStore *self, TpAccount *account, const gchar *chat_id, gboolean chatroom); GList * (*get_chats) (EmpathyLogStore *self, - EmpathyAccount *account); + TpAccount *account); GList * (*search_new) (EmpathyLogStore *self, const gchar *text); void (*ack_message) (EmpathyLogStore *self, const gchar *chat_id, gboolean chatroom, EmpathyMessage *message); - GList * (*get_filtered_messages) (EmpathyLogStore *self, EmpathyAccount *account, + GList * (*get_filtered_messages) (EmpathyLogStore *self, TpAccount *account, const gchar *chat_id, gboolean chatroom, guint num_messages, EmpathyLogMessageFilter filter, gpointer user_data); }; @@ -75,25 +75,25 @@ GType empathy_log_store_get_type (void) G_GNUC_CONST; const gchar *empathy_log_store_get_name (EmpathyLogStore *self); gboolean empathy_log_store_exists (EmpathyLogStore *self, - EmpathyAccount *account, const gchar *chat_id, gboolean chatroom); + TpAccount *account, const gchar *chat_id, gboolean chatroom); gboolean empathy_log_store_add_message (EmpathyLogStore *self, const gchar *chat_id, gboolean chatroom, EmpathyMessage *message, GError **error); GList *empathy_log_store_get_dates (EmpathyLogStore *self, - EmpathyAccount *account, const gchar *chat_id, gboolean chatroom); + TpAccount *account, const gchar *chat_id, gboolean chatroom); GList *empathy_log_store_get_messages_for_date (EmpathyLogStore *self, - EmpathyAccount *account, const gchar *chat_id, gboolean chatroom, + TpAccount *account, const gchar *chat_id, gboolean chatroom, const gchar *date); GList *empathy_log_store_get_last_messages (EmpathyLogStore *self, - EmpathyAccount *account, const gchar *chat_id, gboolean chatroom); + TpAccount *account, const gchar *chat_id, gboolean chatroom); GList *empathy_log_store_get_chats (EmpathyLogStore *self, - EmpathyAccount *account); + TpAccount *account); GList *empathy_log_store_search_new (EmpathyLogStore *self, const gchar *text); void empathy_log_store_ack_message (EmpathyLogStore *self, const gchar *chat_id, gboolean chatroom, EmpathyMessage *message); GList *empathy_log_store_get_filtered_messages (EmpathyLogStore *self, - EmpathyAccount *account, const gchar *chat_id, gboolean chatroom, + TpAccount *account, const gchar *chat_id, gboolean chatroom, guint num_messages, EmpathyLogMessageFilter filter, gpointer user_data); G_END_DECLS diff --git a/libempathy/empathy-tp-roomlist.c b/libempathy/empathy-tp-roomlist.c index 54d232339..2e95f3957 100644 --- a/libempathy/empathy-tp-roomlist.c +++ b/libempathy/empathy-tp-roomlist.c @@ -28,8 +28,6 @@ #include <telepathy-glib/util.h> #include <telepathy-glib/interfaces.h> -#include "empathy-account.h" - #include "empathy-tp-roomlist.h" #include "empathy-chatroom.h" #include "empathy-utils.h" @@ -41,7 +39,7 @@ typedef struct { TpConnection *connection; TpChannel *channel; - EmpathyAccount *account; + TpAccount *account; gboolean is_listing; gboolean start_requested; } EmpathyTpRoomlistPriv; @@ -354,7 +352,7 @@ tp_roomlist_constructed (GObject *list) { EmpathyTpRoomlistPriv *priv = GET_PRIV (list); - priv->connection = empathy_account_get_connection (priv->account); + priv->connection = tp_account_get_connection (priv->account); g_object_ref (priv->connection); tp_cli_connection_call_request_channel (priv->connection, -1, @@ -421,7 +419,7 @@ empathy_tp_roomlist_class_init (EmpathyTpRoomlistClass *klass) g_param_spec_object ("account", "The Account", "The account on which it lists rooms", - EMPATHY_TYPE_ACCOUNT, + TP_TYPE_ACCOUNT, G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY)); g_object_class_install_property (object_class, @@ -477,7 +475,7 @@ empathy_tp_roomlist_init (EmpathyTpRoomlist *list) } EmpathyTpRoomlist * -empathy_tp_roomlist_new (EmpathyAccount *account) +empathy_tp_roomlist_new (TpAccount *account) { EmpathyTpRoomlist *list; diff --git a/libempathy/empathy-tp-roomlist.h b/libempathy/empathy-tp-roomlist.h index 801e5c69f..f400766a9 100644 --- a/libempathy/empathy-tp-roomlist.h +++ b/libempathy/empathy-tp-roomlist.h @@ -24,8 +24,8 @@ #include <glib.h> +#include <telepathy-glib/account.h> #include <telepathy-glib/connection.h> -#include <libempathy/empathy-account.h> G_BEGIN_DECLS @@ -49,7 +49,7 @@ struct _EmpathyTpRoomlistClass { }; GType empathy_tp_roomlist_get_type (void) G_GNUC_CONST; -EmpathyTpRoomlist *empathy_tp_roomlist_new (EmpathyAccount *account); +EmpathyTpRoomlist *empathy_tp_roomlist_new (TpAccount *account); gboolean empathy_tp_roomlist_is_listing (EmpathyTpRoomlist *list); void empathy_tp_roomlist_start (EmpathyTpRoomlist *list); void empathy_tp_roomlist_stop (EmpathyTpRoomlist *list); diff --git a/libempathy/empathy-utils.c b/libempathy/empathy-utils.c index a0cb4111e..21b0599c8 100644 --- a/libempathy/empathy-utils.c +++ b/libempathy/empathy-utils.c @@ -1,4 +1,3 @@ -/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */ /* * Copyright (C) 2003-2007 Imendio AB * Copyright (C) 2007-2008 Collabora Ltd. @@ -32,6 +31,8 @@ #include <glib/gi18n-lib.h> #include <libxml/uri.h> + +#include <telepathy-glib/account-manager.h> #include <telepathy-glib/connection.h> #include <telepathy-glib/channel.h> #include <telepathy-glib/dbus.h> @@ -490,3 +491,67 @@ empathy_signal_connect_weak (gpointer instance, g_object_weak_ref (instance_obj, instance_destroyed_cb, ctx); g_object_weak_ref (user_data, user_data_destroyed_cb, ctx); } + +/* 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) +{ + TpAccountManager *manager; + GList *accounts, *l; + gboolean out_connecting = FALSE; + gboolean out_connected = FALSE; + + manager = tp_account_manager_dup (); + accounts = tp_account_manager_get_valid_accounts (manager); + + for (l = accounts; l != NULL; l = l->next) + { + TpConnectionStatus s = tp_account_get_connection_status ( + TP_ACCOUNT (l->data), NULL); + + if (s == TP_CONNECTION_STATUS_CONNECTING) + out_connecting = TRUE; + else if (s == TP_CONNECTION_STATUS_CONNECTED) + out_connected = TRUE; + + if (out_connecting && out_connected) + break; + } + + g_list_free (accounts); + g_object_unref (manager); + + if (connecting != NULL) + *connecting = out_connecting; + + return out_connected; +} diff --git a/libempathy/empathy-utils.h b/libempathy/empathy-utils.h index d62e096ae..97e5e85b7 100644 --- a/libempathy/empathy-utils.h +++ b/libempathy/empathy-utils.h @@ -85,6 +85,10 @@ void empathy_signal_connect_weak (gpointer instance, GCallback c_handler, GObject *user_data); +TpAccount * empathy_get_account_for_connection (TpConnection *connection); + +gboolean empathy_account_manager_get_accounts_connected (gboolean *connecting); + G_END_DECLS #endif /* __EMPATHY_UTILS_H__ */ |