libempathy/empathy-account-manager.c

   1 /*
   2  * Copyright (C) 2008 Collabora Ltd.
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  17  *
  18  * Authors: Cosimo Cecchi <cosimo.cecchi@collabora.co.uk>
  19  *          Sjoerd Simons <sjoerd.simons@collabora.co.uk>
  20  */
  21
  22 #include "config.h"
  23
  24 #include <telepathy-glib/util.h>
  25 #include <telepathy-glib/account-manager.h>
  26 #include <telepathy-glib/enums.h>
  27 #include <telepathy-glib/defs.h>
  28 #include <telepathy-glib/interfaces.h>
  29
  30 #include "empathy-account-manager.h"
  31 #include "empathy-marshal.h"
  32 #include "empathy-utils.h"
  33
  34 #define DEBUG_FLAG EMPATHY_DEBUG_ACCOUNT
  35 #include <libempathy/empathy-debug.h>
  36
  37 #define GET_PRIV(obj) EMPATHY_GET_PRIV (obj, EmpathyAccountManager)
  38
  39 #define MC5_BUS_NAME "org.freedesktop.Telepathy.MissionControl5"
  40
  41 typedef struct {
  42   /* (owned) unique name -> (reffed) EmpathyAccount */
  43   GHashTable       *accounts;
  44   int               connected;
  45   int               connecting;
  46   gboolean          dispose_run;
  47   gboolean          ready;
  48   TpProxySignalConnection *proxy_signal;
  49   TpAccountManager *tp_manager;
  50   TpDBusDaemon *dbus;
  51
  52   /* global presence */
  53   EmpathyAccount *global_account;
  54
  55   TpConnectionPresenceType global_presence;
  56   gchar *global_status;
  57   gchar *global_status_message;
  58 } EmpathyAccountManagerPriv;
  59
  60 enum {
  61   ACCOUNT_CREATED,
  62   ACCOUNT_DELETED,
  63   ACCOUNT_ENABLED,
  64   ACCOUNT_DISABLED,
  65   ACCOUNT_CHANGED,
  66   ACCOUNT_CONNECTION_CHANGED,
  67   GLOBAL_PRESENCE_CHANGED,
  68   NEW_CONNECTION,
  69   LAST_SIGNAL
  70 };
  71
  72 enum {
  73   PROP_READY = 1,
  74 };
  75
  76 static guint signals[LAST_SIGNAL];
  77 static EmpathyAccountManager *manager_singleton = NULL;
  78
  79 G_DEFINE_TYPE (EmpathyAccountManager, empathy_account_manager, G_TYPE_OBJECT);
  80
  81 static void
  82 emp_account_connection_cb (EmpathyAccount *account,
  83   GParamSpec *spec,
  84   gpointer manager)
  85 {
  86   TpConnection *connection = empathy_account_get_connection (account);
  87
  88   DEBUG ("Signalling connection %p of account %s",
  89       connection, empathy_account_get_unique_name (account));
  90
  91   if (connection != NULL)
  92     g_signal_emit (manager, signals[NEW_CONNECTION], 0, connection);
  93 }
  94
  95 static void
  96 emp_account_enabled_cb (EmpathyAccount *account,
  97   GParamSpec *spec,
  98   gpointer manager)
  99 {
 100   if (empathy_account_is_enabled (account))
 101     g_signal_emit (manager, signals[ACCOUNT_ENABLED], 0, account);
 102   else
 103     g_signal_emit (manager, signals[ACCOUNT_DISABLED], 0, account);
 104 }
 105
 106 static void
 107 emp_account_status_changed_cb (EmpathyAccount *account,
 108   TpConnectionStatus old,
 109   TpConnectionStatus new,
 110   TpConnectionStatusReason reason,
 111   gpointer user_data)
 112 {
 113   EmpathyAccountManager *manager = EMPATHY_ACCOUNT_MANAGER (user_data);
 114   EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
 115
 116   switch (old)
 117     {
 118       case TP_CONNECTION_STATUS_CONNECTING:
 119         priv->connecting--;
 120         break;
 121       case TP_CONNECTION_STATUS_CONNECTED:
 122         priv->connected--;
 123         break;
 124       default:
 125         break;
 126     }
 127
 128   switch (new)
 129     {
 130       case TP_CONNECTION_STATUS_CONNECTING:
 131         priv->connecting++;
 132         break;
 133       case TP_CONNECTION_STATUS_CONNECTED:
 134         priv->connected++;
 135         break;
 136       default:
 137         break;
 138     }
 139
 140   g_signal_emit (manager, signals[ACCOUNT_CONNECTION_CHANGED], 0,
 141     account, reason, new, old);
 142 }
 143
 144 static void
 145 emp_account_manager_update_global_presence (EmpathyAccountManager *manager)
 146 {
 147   EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
 148   TpConnectionPresenceType presence = TP_CONNECTION_PRESENCE_TYPE_UNSET;
 149   EmpathyAccount *account = NULL;
 150   GHashTableIter iter;
 151   gpointer value;
 152
 153   g_hash_table_iter_init (&iter, priv->accounts);
 154   while (g_hash_table_iter_next (&iter, NULL, &value))
 155     {
 156       EmpathyAccount *a = EMPATHY_ACCOUNT (value);
 157       TpConnectionPresenceType p;
 158
 159       g_object_get (a, "presence", &p, NULL);
 160
 161       if (tp_connection_presence_type_cmp_availability (p, presence) > 0)
 162         {
 163           account = a;
 164           presence = p;
 165         }
 166     }
 167
 168   priv->global_account = account;
 169   g_free (priv->global_status);
 170   g_free (priv->global_status_message);
 171
 172   if (account == NULL)
 173     {
 174       priv->global_status = NULL;
 175       priv->global_status_message = NULL;
 176       return;
 177     }
 178
 179   g_object_get (account,
 180     "presence", &priv->global_presence,
 181     "status", &priv->global_status,
 182     "status-message", &priv->global_status_message,
 183     NULL);
 184 }
 185
 186 static void
 187 emp_account_presence_changed_cb (EmpathyAccount *account,
 188   TpConnectionPresenceType presence,
 189   const gchar *status,
 190   const gchar *status_message,
 191   gpointer user_data)
 192 {
 193   EmpathyAccountManager *manager = EMPATHY_ACCOUNT_MANAGER (user_data);
 194   EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
 195
 196   if (tp_connection_presence_type_cmp_availability (presence,
 197       priv->global_presence) > 0)
 198     {
 199       priv->global_account = account;
 200
 201       priv->global_presence = presence;
 202
 203       g_free (priv->global_status);
 204       priv->global_status = g_strdup (status);
 205
 206       g_free (priv->global_status_message);
 207       priv->global_status_message = g_strdup (status_message);
 208
 209       goto signal;
 210     }
 211   else if (priv->global_account == account)
 212     {
 213       emp_account_manager_update_global_presence (manager);
 214       goto signal;
 215     }
 216
 217   return;
 218 signal:
 219     g_signal_emit (manager, signals[GLOBAL_PRESENCE_CHANGED], 0,
 220       priv->global_presence, priv->global_status, priv->global_status_message);
 221 }
 222
 223 static void
 224 empathy_account_manager_check_ready (EmpathyAccountManager *manager)
 225 {
 226   EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
 227   GHashTableIter iter;
 228   gpointer value;
 229
 230   if (priv->ready)
 231     return;
 232
 233   g_hash_table_iter_init (&iter, priv->accounts);
 234   while (g_hash_table_iter_next (&iter, NULL, &value))
 235     {
 236       EmpathyAccount *account = EMPATHY_ACCOUNT (value);
 237       gboolean ready;
 238
 239       g_object_get (account, "ready", &ready, NULL);
 240
 241       if (!ready)
 242         return;
 243     }
 244
 245   priv->ready = TRUE;
 246   g_object_notify (G_OBJECT (manager), "ready");
 247 }
 248
 249 static void
 250 emp_account_ready_cb (GObject *obj, GParamSpec *spec, gpointer user_data)
 251 {
 252   EmpathyAccountManager *manager = EMPATHY_ACCOUNT_MANAGER (user_data);
 253   EmpathyAccount *account = EMPATHY_ACCOUNT (obj);
 254   gboolean ready;
 255
 256   g_object_get (account, "ready", &ready, NULL);
 257
 258   if (!ready)
 259     return;
 260
 261   g_signal_emit (manager, signals[ACCOUNT_CREATED], 0, account);
 262
 263   g_signal_connect (account, "notify::connection",
 264     G_CALLBACK (emp_account_connection_cb), manager);
 265
 266   g_signal_connect (account, "notify::enabled",
 267     G_CALLBACK (emp_account_enabled_cb), manager);
 268
 269   g_signal_connect (account, "status-changed",
 270     G_CALLBACK (emp_account_status_changed_cb), manager);
 271
 272   g_signal_connect (account, "presence-changed",
 273     G_CALLBACK (emp_account_presence_changed_cb), manager);
 274
 275   empathy_account_manager_check_ready (manager);
 276 }
 277
 278 static void
 279 account_manager_got_all_cb (TpProxy *proxy,
 280     GHashTable *properties,
 281     const GError *error,
 282     gpointer user_data,
 283     GObject *weak_object)
 284 {
 285   EmpathyAccountManager *manager = EMPATHY_ACCOUNT_MANAGER (weak_object);
 286   EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
 287   GPtrArray *accounts;
 288   int i;
 289
 290   if (error != NULL)
 291     {
 292       DEBUG ("Failed to get account manager properties: %s", error->message);
 293       return;
 294     }
 295
 296   accounts = tp_asv_get_boxed (properties, "ValidAccounts",
 297     EMPATHY_ARRAY_TYPE_OBJECT);
 298
 299   for (i = 0; i < accounts->len; i++)
 300     {
 301       EmpathyAccount *account;
 302       gchar *name = g_ptr_array_index (accounts, i);
 303
 304       account = empathy_account_new (priv->dbus, name);
 305       g_hash_table_insert (priv->accounts, g_strdup (name), account);
 306
 307       g_signal_connect (account, "notify::ready",
 308         G_CALLBACK (emp_account_ready_cb), manager);
 309     }
 310
 311   empathy_account_manager_check_ready (manager);
 312 }
 313
 314 static void
 315 account_manager_name_owner_changed_cb (TpDBusDaemon *proxy,
 316     const gchar *arg0,
 317     const gchar *arg1,
 318     const gchar *arg2,
 319     gpointer user_data,
 320     GObject *weak_object)
 321 {
 322   EmpathyAccountManager *manager = EMPATHY_ACCOUNT_MANAGER (weak_object);
 323   EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
 324
 325   tp_proxy_signal_connection_disconnect (priv->proxy_signal);
 326   priv->proxy_signal = NULL;
 327
 328   priv->tp_manager = tp_account_manager_new (priv->dbus);
 329   tp_cli_dbus_properties_call_get_all (priv->tp_manager, -1,
 330     TP_IFACE_ACCOUNT_MANAGER,
 331     account_manager_got_all_cb,
 332     NULL,
 333     NULL,
 334     G_OBJECT (manager));
 335 }
 336
 337 static void
 338 empathy_account_manager_init (EmpathyAccountManager *manager)
 339 {
 340   EmpathyAccountManagerPriv *priv;
 341   TpProxy *mc5_proxy;
 342
 343   priv = G_TYPE_INSTANCE_GET_PRIVATE (manager,
 344       EMPATHY_TYPE_ACCOUNT_MANAGER, EmpathyAccountManagerPriv);
 345
 346   manager->priv = priv;
 347   priv->connected = priv->connecting = 0;
 348   priv->global_presence = TP_CONNECTION_PRESENCE_TYPE_UNSET;
 349
 350   priv->accounts = g_hash_table_new_full (g_str_hash, g_str_equal,
 351       g_free, (GDestroyNotify) g_object_unref);
 352
 353   priv->dbus = tp_dbus_daemon_dup (NULL);
 354
 355   priv->proxy_signal = tp_cli_dbus_daemon_connect_to_name_owner_changed (
 356       priv->dbus,
 357       account_manager_name_owner_changed_cb,
 358       TP_ACCOUNT_MANAGER_BUS_NAME,
 359       NULL,
 360       G_OBJECT (manager),
 361       NULL);
 362
 363   /* trigger MC5 starting */
 364   mc5_proxy = g_object_new (TP_TYPE_PROXY,
 365     "dbus-daemon", priv->dbus,
 366     "dbus-connection", tp_proxy_get_dbus_connection (TP_PROXY (priv->dbus)),
 367     "bus-name", MC5_BUS_NAME,
 368     "object-path", "/",
 369     NULL);
 370
 371   tp_cli_dbus_peer_call_ping (mc5_proxy, -1, NULL, NULL, NULL, NULL);
 372
 373   g_object_unref (mc5_proxy);
 374 }
 375
 376 static void
 377 do_finalize (GObject *obj)
 378 {
 379   EmpathyAccountManager *manager = EMPATHY_ACCOUNT_MANAGER (obj);
 380   EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
 381
 382   g_hash_table_destroy (priv->accounts);
 383
 384   G_OBJECT_CLASS (empathy_account_manager_parent_class)->finalize (obj);
 385 }
 386
 387 static void
 388 do_dispose (GObject *obj)
 389 {
 390   EmpathyAccountManager *manager = EMPATHY_ACCOUNT_MANAGER (obj);
 391   EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
 392
 393   if (priv->dispose_run)
 394     return;
 395
 396   priv->dispose_run = TRUE;
 397
 398   if (priv->dbus == NULL)
 399     g_object_unref (priv->dbus);
 400   priv->dbus = NULL;
 401
 402   G_OBJECT_CLASS (empathy_account_manager_parent_class)->dispose (obj);
 403 }
 404
 405 static GObject *
 406 do_constructor (GType type,
 407                 guint n_construct_params,
 408                 GObjectConstructParam *construct_params)
 409 {
 410   GObject *retval;
 411
 412   if (!manager_singleton)
 413     {
 414       retval = G_OBJECT_CLASS (empathy_account_manager_parent_class)->constructor (type,
 415                                                                                    n_construct_params,
 416                                                                                    construct_params);
 417       manager_singleton = EMPATHY_ACCOUNT_MANAGER (retval);
 418       g_object_add_weak_pointer (retval, (gpointer) &manager_singleton);
 419     }
 420   else
 421     {
 422       retval = g_object_ref (manager_singleton);
 423     }
 424
 425   return retval;
 426 }
 427
 428 static void
 429 do_get_property (GObject *object,
 430     guint prop_id,
 431     GValue *value,
 432     GParamSpec *pspec)
 433 {
 434   EmpathyAccountManager *manager = EMPATHY_ACCOUNT_MANAGER (object);
 435   EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
 436
 437   switch (prop_id)
 438     {
 439       case PROP_READY:
 440         g_value_set_boolean (value, priv->ready);
 441         break;
 442       default:
 443         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 444         break;
 445     }
 446 }
 447
 448 static void
 449 empathy_account_manager_class_init (EmpathyAccountManagerClass *klass)
 450 {
 451   GObjectClass *oclass = G_OBJECT_CLASS (klass);
 452
 453   oclass->finalize = do_finalize;
 454   oclass->dispose = do_dispose;
 455   oclass->constructor = do_constructor;
 456   oclass->get_property = do_get_property;
 457
 458   g_object_class_install_property (oclass, PROP_READY,
 459     g_param_spec_boolean ("ready",
 460       "Ready",
 461       "Whether the initial state dump from the account manager is finished",
 462       FALSE,
 463       G_PARAM_STATIC_STRINGS | G_PARAM_READABLE));
 464
 465   signals[ACCOUNT_CREATED] =
 466     g_signal_new ("account-created",
 467                   G_TYPE_FROM_CLASS (klass),
 468                   G_SIGNAL_RUN_LAST,
 469                   0,
 470                   NULL, NULL,
 471                   g_cclosure_marshal_VOID__OBJECT,
 472                   G_TYPE_NONE,
 473                   1, EMPATHY_TYPE_ACCOUNT);
 474
 475   signals[ACCOUNT_DELETED] =
 476     g_signal_new ("account-deleted",
 477                   G_TYPE_FROM_CLASS (klass),
 478                   G_SIGNAL_RUN_LAST,
 479                   0,
 480                   NULL, NULL,
 481                   g_cclosure_marshal_VOID__OBJECT,
 482                   G_TYPE_NONE,
 483                   1, EMPATHY_TYPE_ACCOUNT);
 484
 485   signals[ACCOUNT_ENABLED] =
 486     g_signal_new ("account-enabled",
 487                   G_TYPE_FROM_CLASS (klass),
 488                   G_SIGNAL_RUN_LAST,
 489                   0,
 490                   NULL, NULL,
 491                   g_cclosure_marshal_VOID__OBJECT,
 492                   G_TYPE_NONE,
 493                   1, EMPATHY_TYPE_ACCOUNT);
 494
 495   signals[ACCOUNT_DISABLED] =
 496     g_signal_new ("account-disabled",
 497                   G_TYPE_FROM_CLASS (klass),
 498                   G_SIGNAL_RUN_LAST,
 499                   0,
 500                   NULL, NULL,
 501                   g_cclosure_marshal_VOID__OBJECT,
 502                   G_TYPE_NONE,
 503                   1, EMPATHY_TYPE_ACCOUNT);
 504
 505   signals[ACCOUNT_CHANGED] =
 506     g_signal_new ("account-changed",
 507                   G_TYPE_FROM_CLASS (klass),
 508                   G_SIGNAL_RUN_LAST,
 509                   0,
 510                   NULL, NULL,
 511                   g_cclosure_marshal_VOID__OBJECT,
 512                   G_TYPE_NONE,
 513                   1, EMPATHY_TYPE_ACCOUNT);
 514
 515   signals[ACCOUNT_CONNECTION_CHANGED] =
 516     g_signal_new ("account-connection-changed",
 517                   G_TYPE_FROM_CLASS (klass),
 518                   G_SIGNAL_RUN_LAST,
 519                   0,
 520                   NULL, NULL,
 521                   _empathy_marshal_VOID__OBJECT_INT_UINT_UINT,
 522                   G_TYPE_NONE,
 523                   4, EMPATHY_TYPE_ACCOUNT,
 524                   G_TYPE_INT,   /* reason */
 525                   G_TYPE_UINT,  /* actual connection */
 526                   G_TYPE_UINT); /* previous connection */
 527
 528   signals[GLOBAL_PRESENCE_CHANGED] =
 529     g_signal_new ("global-presence-changed",
 530                   G_TYPE_FROM_CLASS (klass),
 531                   G_SIGNAL_RUN_LAST,
 532                   0,
 533                   NULL, NULL,
 534                   _empathy_marshal_VOID__UINT_STRING_STRING,
 535                   G_TYPE_NONE,
 536                   3, G_TYPE_UINT, /* Presence type */
 537                   G_TYPE_STRING,  /* status */
 538                   G_TYPE_STRING); /* stauts message*/
 539
 540   signals[NEW_CONNECTION] =
 541     g_signal_new ("new-connection",
 542                   G_TYPE_FROM_CLASS (klass),
 543                   G_SIGNAL_RUN_LAST,
 544                   0,
 545                   NULL, NULL,
 546                   g_cclosure_marshal_VOID__OBJECT,
 547                   G_TYPE_NONE,
 548                   1, TP_TYPE_CONNECTION);
 549
 550   g_type_class_add_private (oclass, sizeof (EmpathyAccountManagerPriv));
 551 }
 552
 553 /* public methods */
 554
 555 EmpathyAccountManager *
 556 empathy_account_manager_dup_singleton (void)
 557 {
 558   return g_object_new (EMPATHY_TYPE_ACCOUNT_MANAGER, NULL);
 559 }
 560
 561 EmpathyAccount *
 562 empathy_account_manager_create (EmpathyAccountManager *manager,
 563         const gchar *connection_manager,
 564         const gchar *protocol,
 565         const gchar *display_name)
 566 {
 567   /* FIXME */
 568   return NULL;
 569 }
 570
 571
 572 gboolean
 573 empathy_account_manager_is_ready (EmpathyAccountManager *manager)
 574 {
 575   EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
 576
 577   return priv->ready;
 578 }
 579
 580 int
 581 empathy_account_manager_get_connected_accounts (EmpathyAccountManager *manager)
 582 {
 583   EmpathyAccountManagerPriv *priv;
 584
 585   g_return_val_if_fail (EMPATHY_IS_ACCOUNT_MANAGER (manager), 0);
 586
 587   priv = GET_PRIV (manager);
 588
 589   return priv->connected;
 590 }
 591
 592 int
 593 empathy_account_manager_get_connecting_accounts (EmpathyAccountManager *manager)
 594 {
 595   EmpathyAccountManagerPriv *priv;
 596
 597   g_return_val_if_fail (EMPATHY_IS_ACCOUNT_MANAGER (manager), 0);
 598
 599   priv = GET_PRIV (manager);
 600
 601   return priv->connecting;
 602 }
 603
 604 /**
 605  * empathy_account_manager_get_count:
 606  * @manager: a #EmpathyAccountManager
 607  *
 608  * Get the number of accounts.
 609  *
 610  * Returns: the number of accounts.
 611  **/
 612 int
 613 empathy_account_manager_get_count (EmpathyAccountManager *manager)
 614 {
 615   EmpathyAccountManagerPriv *priv;
 616
 617   g_return_val_if_fail (EMPATHY_IS_ACCOUNT_MANAGER (manager), 0);
 618
 619   priv = GET_PRIV (manager);
 620
 621   return g_hash_table_size (priv->accounts);
 622 }
 623
 624 EmpathyAccount *
 625 empathy_account_manager_get_account (EmpathyAccountManager *manager,
 626                                      TpConnection          *connection)
 627 {
 628   EmpathyAccountManagerPriv *priv;
 629   GHashTableIter iter;
 630   gpointer value;
 631
 632   g_return_val_if_fail (EMPATHY_IS_ACCOUNT_MANAGER (manager), 0);
 633
 634   priv = GET_PRIV (manager);
 635
 636   g_hash_table_iter_init (&iter, priv->accounts);
 637   while (g_hash_table_iter_next (&iter, NULL, &value))
 638     {
 639       EmpathyAccount *account = EMPATHY_ACCOUNT (value);
 640
 641       if (connection == empathy_account_get_connection (account))
 642           return account;
 643     }
 644
 645   return NULL;
 646 }
 647
 648 EmpathyAccount *
 649 empathy_account_manager_lookup (EmpathyAccountManager *manager,
 650     const gchar *unique_name)
 651 {
 652   EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
 653   EmpathyAccount *account;
 654
 655   account = g_hash_table_lookup (priv->accounts, unique_name);
 656
 657   if (account != NULL)
 658     g_object_ref (account);
 659
 660   return account;
 661 }
 662
 663 GList *
 664 empathy_account_manager_dup_accounts (EmpathyAccountManager *manager)
 665 {
 666   EmpathyAccountManagerPriv *priv;
 667   GList *ret;
 668
 669   g_return_val_if_fail (EMPATHY_IS_ACCOUNT_MANAGER (manager), NULL);
 670
 671   priv = GET_PRIV (manager);
 672
 673   ret = g_hash_table_get_values (priv->accounts);
 674   g_list_foreach (ret, (GFunc) g_object_ref, NULL);
 675
 676   return ret;
 677 }
 678
 679 /**
 680  * empathy_account_manager_dup_connections:
 681  * @manager: a #EmpathyAccountManager
 682  *
 683  * Get a #GList of all ready #TpConnection. The list must be freed with
 684  * g_list_free, and its elements must be unreffed.
 685  *
 686  * Returns: the list of connections
 687  **/
 688 GList *
 689 empathy_account_manager_dup_connections (EmpathyAccountManager *manager)
 690 {
 691   EmpathyAccountManagerPriv *priv;
 692   GHashTableIter iter;
 693   gpointer value;
 694   GList *ret = NULL;
 695
 696   g_return_val_if_fail (EMPATHY_IS_ACCOUNT_MANAGER (manager), NULL);
 697
 698   priv = GET_PRIV (manager);
 699
 700   g_hash_table_iter_init (&iter, priv->accounts);
 701   while (g_hash_table_iter_next (&iter, NULL, &value))
 702     {
 703       EmpathyAccount *account = EMPATHY_ACCOUNT (value);
 704       TpConnection *connection;
 705
 706       connection = empathy_account_get_connection (account);
 707       if (connection != NULL)
 708         ret = g_list_prepend (ret, g_object_ref (connection));
 709     }
 710
 711   return ret;
 712 }
 713
 714 void
 715 empathy_account_manager_remove (EmpathyAccountManager *manager,
 716     EmpathyAccount *account)
 717 {
 718   /* FIXME */
 719 }
 720
 721
 722 void
 723 empathy_account_manager_request_global_presence (
 724   EmpathyAccountManager *manager,
 725   TpConnectionPresenceType type,
 726   const gchar *status,
 727   const gchar *message)
 728 {
 729   /* FIXME should remember requested presence and set it on new accounts
 730      as well */
 731   EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
 732   GHashTableIter iter;
 733   gpointer value;
 734
 735   g_hash_table_iter_init (&iter, priv->accounts);
 736   while (g_hash_table_iter_next (&iter, NULL, &value))
 737     {
 738       EmpathyAccount *account = EMPATHY_ACCOUNT (value);
 739       gboolean ready;
 740
 741       g_object_get (account, "ready", &ready, NULL);
 742
 743       if (ready)
 744         empathy_account_request_presence (account, type, status, message);
 745     }
 746 }
 747
 748 TpConnectionPresenceType
 749 empathy_account_manager_get_global_presence (
 750   EmpathyAccountManager *manager,
 751   gchar **status,
 752   gchar **message)
 753 {
 754   EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
 755
 756   if (status != NULL)
 757     *status = g_strdup (priv->global_status);
 758   if (message != NULL)
 759     *message = g_strdup (priv->global_status_message);
 760
 761   return priv->global_presence;
 762 }