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  */
  20
  21 #include "config.h"
  22
  23 #include <libmissioncontrol/mc-account-monitor.h>
  24
  25 #include "empathy-account-manager.h"
  26 #include "empathy-marshal.h"
  27 #include "empathy-utils.h"
  28
  29 #define DEBUG_FLAG EMPATHY_DEBUG_ACCOUNT
  30 #include <libempathy/empathy-debug.h>
  31
  32 #define GET_PRIV(obj) EMPATHY_GET_PRIV (obj, EmpathyAccountManager)
  33
  34 typedef struct {
  35   McAccountMonitor *monitor;
  36   MissionControl   *mc;
  37
  38   GHashTable       *accounts; /* McAccount -> AccountData */
  39   GHashTable       *connections; /* TpConnection -> McAccount */
  40   int               connected;
  41   int               connecting;
  42   gboolean          dispose_run;
  43 } EmpathyAccountManagerPriv;
  44
  45 typedef struct {
  46   TpConnection *connection;
  47   TpConnectionPresenceType presence;
  48   TpConnectionStatus status;
  49   gboolean is_enabled;
  50
  51   guint source_id;
  52 } AccountData;
  53
  54 enum {
  55   ACCOUNT_CREATED,
  56   ACCOUNT_DELETED,
  57   ACCOUNT_ENABLED,
  58   ACCOUNT_DISABLED,
  59   ACCOUNT_CHANGED,
  60   ACCOUNT_CONNECTION_CHANGED,
  61   ACCOUNT_PRESENCE_CHANGED,
  62   NEW_CONNECTION,
  63   LAST_SIGNAL
  64 };
  65
  66 static guint signals[LAST_SIGNAL];
  67 static EmpathyAccountManager *manager_singleton = NULL;
  68
  69 G_DEFINE_TYPE (EmpathyAccountManager, empathy_account_manager, G_TYPE_OBJECT);
  70
  71 static AccountData *
  72 account_data_new (McPresence presence,
  73                   TpConnectionStatus status,
  74                   gboolean is_enabled)
  75 {
  76   AccountData *retval;
  77
  78   retval = g_slice_new0 (AccountData);
  79   retval->presence = presence;
  80   retval->status = status;
  81   retval->is_enabled = is_enabled;
  82   retval->source_id = 0;
  83
  84   return retval;
  85 }
  86
  87 static AccountData *
  88 account_data_new_default (MissionControl *mc,
  89                           McAccount *account)
  90 {
  91   McPresence actual_p;
  92   TpConnectionStatus actual_c;
  93   GError *err = NULL;
  94
  95   actual_p = mission_control_get_presence_actual (mc, &err);
  96   if (err != NULL)
  97     {
  98       actual_p = MC_PRESENCE_UNSET;
  99       g_clear_error (&err);
 100     }
 101
 102   actual_c = mission_control_get_connection_status (mc, account, &err);
 103
 104   if (err != NULL)
 105     {
 106       actual_c = TP_CONNECTION_STATUS_DISCONNECTED;
 107       g_error_free (err);
 108     }
 109
 110   return account_data_new (actual_p, actual_c, mc_account_is_enabled (account));
 111 }
 112
 113 static void
 114 account_data_free (AccountData *data)
 115 {
 116   if (data->source_id > 0)
 117     {
 118       g_source_remove (data->source_id);
 119       data->source_id = 0;
 120     }
 121   if (data->connection != NULL)
 122     {
 123       g_object_unref (data->connection);
 124       data->connection = NULL;
 125     }
 126
 127   g_slice_free (AccountData, data);
 128 }
 129
 130 static void
 131 connection_invalidated_cb (TpProxy *connection,
 132                            guint    domain,
 133                            gint     code,
 134                            gchar   *message,
 135                            EmpathyAccountManager *manager)
 136 {
 137   EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
 138   McAccount *account;
 139   AccountData *data;
 140
 141   DEBUG ("Message: %s", message);
 142
 143   account = g_hash_table_lookup (priv->connections, connection);
 144   g_assert (account != NULL);
 145
 146   data = g_hash_table_lookup (priv->accounts, account);
 147   g_assert (data != NULL);
 148
 149   g_object_unref (data->connection);
 150   data->connection = NULL;
 151
 152   g_hash_table_remove (priv->connections, connection);
 153 }
 154
 155 static void
 156 connection_ready_cb (TpConnection *connection,
 157                      const GError *error,
 158                      gpointer manager)
 159 {
 160   /* Errors will be handled in invalidated callback */
 161   if (error != NULL)
 162     return;
 163
 164   g_signal_emit (manager, signals[NEW_CONNECTION], 0, connection);
 165 }
 166
 167 static void
 168 account_manager_update_connection (EmpathyAccountManager *manager,
 169                                    AccountData *data,
 170                                    McAccount *account)
 171 {
 172   EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
 173
 174   if (data->connection)
 175     return;
 176
 177   data->connection = mission_control_get_tpconnection (priv->mc, account, NULL);
 178   if (data->connection != NULL)
 179     {
 180       g_signal_connect (data->connection, "invalidated",
 181           G_CALLBACK (connection_invalidated_cb), manager);
 182       g_hash_table_insert (priv->connections, g_object_ref (data->connection),
 183           g_object_ref (account));
 184       tp_connection_call_when_ready (data->connection, connection_ready_cb,
 185           manager);
 186     }
 187 }
 188
 189 static void
 190 account_created_cb (McAccountMonitor *mon,
 191                     gchar *account_name,
 192                     EmpathyAccountManager *manager)
 193 {
 194   McAccount *account;
 195   EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
 196   TpConnectionStatus initial_status;
 197
 198   account = mc_account_lookup (account_name);
 199
 200   if (account)
 201     {
 202       AccountData *data;
 203
 204       data = account_data_new_default (priv->mc, account);
 205       g_hash_table_insert (priv->accounts, g_object_ref (account), data);
 206
 207       initial_status = mission_control_get_connection_status (priv->mc,
 208                                                               account, NULL);
 209
 210       if (initial_status == TP_CONNECTION_STATUS_CONNECTED)
 211         priv->connected++;
 212       else if (initial_status == TP_CONNECTION_STATUS_CONNECTING)
 213         priv->connecting++;
 214
 215       account_manager_update_connection (manager, data, account);
 216
 217       g_signal_emit (manager, signals[ACCOUNT_CREATED], 0, account);
 218       g_object_unref (account);
 219     }
 220 }
 221
 222 static void
 223 account_deleted_cb (McAccountMonitor *mon,
 224                     gchar *account_name,
 225                     EmpathyAccountManager *manager)
 226 {
 227   McAccount *account;
 228   EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
 229
 230   account = mc_account_lookup (account_name);
 231
 232   if (account)
 233     {
 234       g_hash_table_remove (priv->accounts, account);
 235       g_signal_emit (manager, signals[ACCOUNT_DELETED], 0, account);
 236       g_object_unref (account);
 237     }
 238 }
 239
 240 static void
 241 account_changed_cb (McAccountMonitor *mon,
 242                     gchar *account_name,
 243                     EmpathyAccountManager *manager)
 244 {
 245   McAccount *account;
 246
 247   account = mc_account_lookup (account_name);
 248
 249   if (account)
 250     {
 251       g_signal_emit (manager, signals[ACCOUNT_CHANGED], 0, account);
 252       g_object_unref (account);
 253     }
 254 }
 255
 256 static void
 257 account_disabled_cb (McAccountMonitor *mon,
 258                      gchar *account_name,
 259                      EmpathyAccountManager *manager)
 260 {
 261   McAccount *account;
 262   EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
 263   AccountData *data;
 264
 265   account = mc_account_lookup (account_name);
 266
 267   if (account)
 268     {
 269       data = g_hash_table_lookup (priv->accounts, account);
 270       g_assert (data);
 271       data->is_enabled = FALSE;
 272
 273       g_signal_emit (manager, signals[ACCOUNT_DISABLED], 0, account);
 274       g_object_unref (account);
 275     }
 276 }
 277
 278 static void
 279 account_enabled_cb (McAccountMonitor *mon,
 280                     gchar *account_name,
 281                     EmpathyAccountManager *manager)
 282 {
 283   McAccount *account;
 284   EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
 285   AccountData *data;
 286
 287   account = mc_account_lookup (account_name);
 288
 289   if (account)
 290     {
 291       data = g_hash_table_lookup (priv->accounts, account);
 292       g_assert (data);
 293       data->is_enabled = TRUE;
 294
 295       g_signal_emit (manager, signals[ACCOUNT_ENABLED], 0, account);
 296       g_object_unref (account);
 297     }
 298 }
 299
 300 static void
 301 update_connection_numbers (EmpathyAccountManager *manager,
 302                            TpConnectionStatus status,
 303                            TpConnectionStatus old_s)
 304 {
 305   EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
 306
 307   if (status == TP_CONNECTION_STATUS_CONNECTED)
 308     {
 309       priv->connected++;
 310       if (old_s == TP_CONNECTION_STATUS_CONNECTING)
 311         priv->connecting--;
 312     }
 313
 314   if (status == TP_CONNECTION_STATUS_CONNECTING)
 315     {
 316       priv->connecting++;
 317       if (old_s == TP_CONNECTION_STATUS_CONNECTED)
 318         priv->connected--;
 319     }
 320
 321   if (status == TP_CONNECTION_STATUS_DISCONNECTED)
 322     {
 323       if (old_s == TP_CONNECTION_STATUS_CONNECTED)
 324         priv->connected--;
 325
 326       if (old_s == TP_CONNECTION_STATUS_CONNECTING)
 327         priv->connecting--;
 328     }
 329 }
 330
 331 static gboolean
 332 remove_data_timeout (gpointer _data)
 333 {
 334   AccountData *data = _data;
 335
 336   data->source_id = 0;
 337
 338   return FALSE;
 339 }
 340
 341 typedef struct {
 342   TpConnectionStatus status;
 343   McPresence presence;
 344   TpConnectionStatusReason reason;
 345   gchar *unique_name;
 346   EmpathyAccountManager *manager;
 347 } ChangedSignalData;
 348
 349 static gboolean
 350 account_status_changed_idle_cb (ChangedSignalData *signal_data)
 351 {
 352   McAccount *account;
 353   AccountData *data;
 354   McPresence presence, old_p;
 355   TpConnectionStatus status, old_s;
 356   gboolean emit_presence = FALSE, emit_connection = FALSE;
 357   EmpathyAccountManager *manager = signal_data->manager;
 358   EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
 359
 360   presence = signal_data->presence;
 361   status = signal_data->status;
 362   account = mc_account_lookup (signal_data->unique_name);
 363
 364   if (account)
 365     {
 366       data = g_hash_table_lookup (priv->accounts, account);
 367       g_assert (data);
 368
 369       old_p = data->presence;
 370       old_s = data->status;
 371
 372       if (old_p != presence)
 373         {
 374           data->presence = presence;
 375           emit_presence = TRUE;
 376         }
 377
 378       if (old_s != status)
 379         {
 380           data->status = status;
 381           update_connection_numbers (manager, status, old_s);
 382
 383           if (status == TP_CONNECTION_STATUS_CONNECTED)
 384             {
 385                 if (data->source_id > 0)
 386                   {
 387                     g_source_remove (data->source_id);
 388                     data->source_id = 0;
 389                   }
 390
 391                 data->source_id = g_timeout_add_seconds (10,
 392                                                          remove_data_timeout,
 393                                                          data);
 394             }
 395           emit_connection = TRUE;
 396         }
 397
 398       account_manager_update_connection (manager, data, account);
 399
 400       if (emit_presence)
 401         g_signal_emit (manager, signals[ACCOUNT_PRESENCE_CHANGED], 0,
 402                        account, presence, old_p);
 403
 404       if (emit_connection)
 405         g_signal_emit (manager, signals[ACCOUNT_CONNECTION_CHANGED], 0,
 406                        account, signal_data->reason, status, old_s);
 407
 408       g_object_unref (account);
 409     }
 410
 411   g_object_unref (signal_data->manager);
 412   g_free (signal_data->unique_name);
 413   g_slice_free (ChangedSignalData, signal_data);
 414
 415   return FALSE;
 416 }
 417
 418 static void
 419 account_status_changed_cb (MissionControl *mc,
 420                            TpConnectionStatus status,
 421                            McPresence presence,
 422                            TpConnectionStatusReason reason,
 423                            const gchar *unique_name,
 424                            EmpathyAccountManager *manager)
 425 {
 426   ChangedSignalData *data;
 427   TpConnectionPresenceType tp_presence;
 428
 429   switch (presence)
 430     {
 431       case MC_PRESENCE_OFFLINE:
 432         tp_presence = TP_CONNECTION_PRESENCE_TYPE_OFFLINE;
 433         break;
 434       case MC_PRESENCE_AVAILABLE:
 435         tp_presence = TP_CONNECTION_PRESENCE_TYPE_AVAILABLE;
 436         break;
 437       case MC_PRESENCE_AWAY:
 438         tp_presence = TP_CONNECTION_PRESENCE_TYPE_AWAY;
 439         break;
 440       case MC_PRESENCE_EXTENDED_AWAY:
 441         tp_presence = TP_CONNECTION_PRESENCE_TYPE_EXTENDED_AWAY;
 442         break;
 443       case MC_PRESENCE_HIDDEN:
 444         tp_presence = TP_CONNECTION_PRESENCE_TYPE_HIDDEN;
 445         break;
 446       case MC_PRESENCE_DO_NOT_DISTURB:
 447         tp_presence = TP_CONNECTION_PRESENCE_TYPE_BUSY;
 448         break;
 449       default:
 450         tp_presence = TP_CONNECTION_PRESENCE_TYPE_UNSET;
 451     }
 452
 453   data = g_slice_new0 (ChangedSignalData);
 454   data->status = status;
 455   data->presence = tp_presence;
 456   data->reason = reason;
 457   data->unique_name = g_strdup (unique_name);
 458   data->manager = g_object_ref (manager);
 459
 460   g_idle_add ((GSourceFunc) account_status_changed_idle_cb, data);
 461 }
 462
 463 static void
 464 empathy_account_manager_init (EmpathyAccountManager *manager)
 465 {
 466   EmpathyAccountManagerPriv *priv;
 467   GList *mc_accounts, *l;
 468
 469   priv = G_TYPE_INSTANCE_GET_PRIVATE (manager,
 470                                       EMPATHY_TYPE_ACCOUNT_MANAGER, EmpathyAccountManagerPriv);
 471   manager->priv = priv;
 472   priv->monitor = mc_account_monitor_new ();
 473   priv->mc = empathy_mission_control_dup_singleton ();
 474   priv->connected = priv->connecting = 0;
 475   priv->dispose_run = FALSE;
 476
 477   priv->accounts = g_hash_table_new_full (empathy_account_hash,
 478                                           empathy_account_equal,
 479                                           g_object_unref,
 480                                           (GDestroyNotify) account_data_free);
 481   priv->connections = g_hash_table_new_full (g_direct_hash, g_direct_equal,
 482                                              g_object_unref, g_object_unref);
 483
 484   mc_accounts = mc_accounts_list ();
 485
 486   for (l = mc_accounts; l; l = l->next)
 487     account_created_cb (priv->monitor, (char *) mc_account_get_unique_name (l->data), manager);
 488
 489   g_signal_connect (priv->monitor, "account-created",
 490                     G_CALLBACK (account_created_cb), manager);
 491   g_signal_connect (priv->monitor, "account-deleted",
 492                     G_CALLBACK (account_deleted_cb), manager);
 493   g_signal_connect (priv->monitor, "account-disabled",
 494                     G_CALLBACK (account_disabled_cb), manager);
 495   g_signal_connect (priv->monitor, "account-enabled",
 496                     G_CALLBACK (account_enabled_cb), manager);
 497   g_signal_connect (priv->monitor, "account-changed",
 498                     G_CALLBACK (account_changed_cb), manager);
 499
 500   dbus_g_proxy_connect_signal (DBUS_G_PROXY (priv->mc), "AccountStatusChanged",
 501                                G_CALLBACK (account_status_changed_cb),
 502                                manager, NULL);
 503
 504   mc_accounts_list_free (mc_accounts);
 505 }
 506
 507 static void
 508 do_finalize (GObject *obj)
 509 {
 510   EmpathyAccountManager *manager = EMPATHY_ACCOUNT_MANAGER (obj);
 511   EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
 512
 513   g_hash_table_unref (priv->accounts);
 514   g_hash_table_unref (priv->connections);
 515
 516   G_OBJECT_CLASS (empathy_account_manager_parent_class)->finalize (obj);
 517 }
 518
 519 static void
 520 do_dispose (GObject *obj)
 521 {
 522   EmpathyAccountManager *manager = EMPATHY_ACCOUNT_MANAGER (obj);
 523   EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
 524
 525   if (priv->dispose_run)
 526     return;
 527
 528   priv->dispose_run = TRUE;
 529
 530   dbus_g_proxy_disconnect_signal (DBUS_G_PROXY (priv->mc),
 531                                   "AccountStatusChanged",
 532                                   G_CALLBACK (account_status_changed_cb),
 533                                   obj);
 534
 535   if (priv->monitor)
 536     {
 537       g_signal_handlers_disconnect_by_func (priv->monitor,
 538                                             account_created_cb, obj);
 539       g_signal_handlers_disconnect_by_func (priv->monitor,
 540                                             account_deleted_cb, obj);
 541       g_signal_handlers_disconnect_by_func (priv->monitor,
 542                                             account_disabled_cb, obj);
 543       g_signal_handlers_disconnect_by_func (priv->monitor,
 544                                             account_enabled_cb, obj);
 545       g_signal_handlers_disconnect_by_func (priv->monitor,
 546                                             account_changed_cb, obj);
 547       g_object_unref (priv->monitor);
 548       priv->monitor = NULL;
 549     }
 550
 551   if (priv->mc)
 552     g_object_unref (priv->mc);
 553
 554   g_hash_table_remove_all (priv->accounts);
 555
 556   G_OBJECT_CLASS (empathy_account_manager_parent_class)->dispose (obj);
 557 }
 558
 559 static GObject *
 560 do_constructor (GType type,
 561                 guint n_construct_params,
 562                 GObjectConstructParam *construct_params)
 563 {
 564   GObject *retval;
 565
 566   if (!manager_singleton)
 567     {
 568       retval = G_OBJECT_CLASS (empathy_account_manager_parent_class)->constructor (type,
 569                                                                                    n_construct_params,
 570                                                                                    construct_params);
 571       manager_singleton = EMPATHY_ACCOUNT_MANAGER (retval);
 572       g_object_add_weak_pointer (retval, (gpointer) &manager_singleton);
 573     }
 574   else
 575     {
 576       retval = g_object_ref (manager_singleton);
 577     }
 578
 579   return retval;
 580 }
 581
 582 static void
 583 empathy_account_manager_class_init (EmpathyAccountManagerClass *klass)
 584 {
 585   GObjectClass *oclass = G_OBJECT_CLASS (klass);
 586
 587   oclass->finalize = do_finalize;
 588   oclass->dispose = do_dispose;
 589   oclass->constructor = do_constructor;
 590
 591   signals[ACCOUNT_CREATED] =
 592     g_signal_new ("account-created",
 593                   G_TYPE_FROM_CLASS (klass),
 594                   G_SIGNAL_RUN_LAST,
 595                   0,
 596                   NULL, NULL,
 597                   g_cclosure_marshal_VOID__OBJECT,
 598                   G_TYPE_NONE,
 599                   1, MC_TYPE_ACCOUNT);
 600
 601   signals[ACCOUNT_DELETED] =
 602     g_signal_new ("account-deleted",
 603                   G_TYPE_FROM_CLASS (klass),
 604                   G_SIGNAL_RUN_LAST,
 605                   0,
 606                   NULL, NULL,
 607                   g_cclosure_marshal_VOID__OBJECT,
 608                   G_TYPE_NONE,
 609                   1, MC_TYPE_ACCOUNT);
 610
 611   signals[ACCOUNT_ENABLED] =
 612     g_signal_new ("account-enabled",
 613                   G_TYPE_FROM_CLASS (klass),
 614                   G_SIGNAL_RUN_LAST,
 615                   0,
 616                   NULL, NULL,
 617                   g_cclosure_marshal_VOID__OBJECT,
 618                   G_TYPE_NONE,
 619                   1, MC_TYPE_ACCOUNT);
 620
 621   signals[ACCOUNT_DISABLED] =
 622     g_signal_new ("account-disabled",
 623                   G_TYPE_FROM_CLASS (klass),
 624                   G_SIGNAL_RUN_LAST,
 625                   0,
 626                   NULL, NULL,
 627                   g_cclosure_marshal_VOID__OBJECT,
 628                   G_TYPE_NONE,
 629                   1, MC_TYPE_ACCOUNT);
 630
 631   signals[ACCOUNT_CHANGED] =
 632     g_signal_new ("account-changed",
 633                   G_TYPE_FROM_CLASS (klass),
 634                   G_SIGNAL_RUN_LAST,
 635                   0,
 636                   NULL, NULL,
 637                   g_cclosure_marshal_VOID__OBJECT,
 638                   G_TYPE_NONE,
 639                   1, MC_TYPE_ACCOUNT);
 640
 641   signals[ACCOUNT_CONNECTION_CHANGED] =
 642     g_signal_new ("account-connection-changed",
 643                   G_TYPE_FROM_CLASS (klass),
 644                   G_SIGNAL_RUN_LAST,
 645                   0,
 646                   NULL, NULL,
 647                   _empathy_marshal_VOID__OBJECT_INT_UINT_UINT,
 648                   G_TYPE_NONE,
 649                   4, MC_TYPE_ACCOUNT,
 650                   G_TYPE_INT,   /* reason */
 651                   G_TYPE_UINT,  /* actual connection */
 652                   G_TYPE_UINT); /* previous connection */
 653
 654   signals[ACCOUNT_PRESENCE_CHANGED] =
 655     g_signal_new ("account-presence-changed",
 656                   G_TYPE_FROM_CLASS (klass),
 657                   G_SIGNAL_RUN_LAST,
 658                   0,
 659                   NULL, NULL,
 660                   _empathy_marshal_VOID__OBJECT_INT_INT,
 661                   G_TYPE_NONE,
 662                   3, MC_TYPE_ACCOUNT,
 663                   G_TYPE_INT,  /* actual presence */
 664                   G_TYPE_INT); /* previous presence */
 665
 666   signals[NEW_CONNECTION] =
 667     g_signal_new ("new-connection",
 668                   G_TYPE_FROM_CLASS (klass),
 669                   G_SIGNAL_RUN_LAST,
 670                   0,
 671                   NULL, NULL,
 672                   g_cclosure_marshal_VOID__OBJECT,
 673                   G_TYPE_NONE,
 674                   1, TP_TYPE_CONNECTION);
 675
 676   g_type_class_add_private (oclass, sizeof (EmpathyAccountManagerPriv));
 677 }
 678
 679 /* public methods */
 680
 681 EmpathyAccountManager *
 682 empathy_account_manager_dup_singleton (void)
 683 {
 684   return g_object_new (EMPATHY_TYPE_ACCOUNT_MANAGER, NULL);
 685 }
 686
 687 int
 688 empathy_account_manager_get_connected_accounts (EmpathyAccountManager *manager)
 689 {
 690   EmpathyAccountManagerPriv *priv;
 691
 692   g_return_val_if_fail (EMPATHY_IS_ACCOUNT_MANAGER (manager), 0);
 693
 694   priv = GET_PRIV (manager);
 695
 696   return priv->connected;
 697 }
 698
 699 int
 700 empathy_account_manager_get_connecting_accounts (EmpathyAccountManager *manager)
 701 {
 702   EmpathyAccountManagerPriv *priv;
 703
 704   g_return_val_if_fail (EMPATHY_IS_ACCOUNT_MANAGER (manager), 0);
 705
 706   priv = GET_PRIV (manager);
 707
 708   return priv->connecting;
 709 }
 710
 711 gboolean
 712 empathy_account_manager_is_account_just_connected (EmpathyAccountManager *manager,
 713                                                    McAccount *account)
 714 {
 715   EmpathyAccountManagerPriv *priv;
 716   AccountData *data;
 717
 718   g_return_val_if_fail (EMPATHY_IS_ACCOUNT_MANAGER (manager), FALSE);
 719
 720   priv = GET_PRIV (manager);
 721   data = g_hash_table_lookup (priv->accounts, account);
 722
 723   g_assert (data);
 724
 725   return (data->source_id > 0);
 726 }
 727
 728 /**
 729  * empathy_account_manager_get_count:
 730  * @manager: a #EmpathyAccountManager
 731  *
 732  * Get the number of accounts.
 733  *
 734  * Returns: the number of accounts.
 735  **/
 736 int
 737 empathy_account_manager_get_count (EmpathyAccountManager *manager)
 738 {
 739   EmpathyAccountManagerPriv *priv;
 740
 741   g_return_val_if_fail (EMPATHY_IS_ACCOUNT_MANAGER (manager), 0);
 742
 743   priv = GET_PRIV (manager);
 744
 745   return g_hash_table_size (priv->accounts);
 746 }
 747
 748 McAccount *
 749 empathy_account_manager_get_account (EmpathyAccountManager *manager,
 750                                      TpConnection          *connection)
 751 {
 752   EmpathyAccountManagerPriv *priv;
 753
 754   g_return_val_if_fail (EMPATHY_IS_ACCOUNT_MANAGER (manager), 0);
 755
 756   priv = GET_PRIV (manager);
 757
 758   return g_hash_table_lookup (priv->connections, connection);
 759 }
 760
 761 GList *
 762 empathy_account_manager_dup_accounts (EmpathyAccountManager *manager)
 763 {
 764   EmpathyAccountManagerPriv *priv;
 765   GList *ret;
 766
 767   g_return_val_if_fail (EMPATHY_IS_ACCOUNT_MANAGER (manager), NULL);
 768
 769   priv = GET_PRIV (manager);
 770
 771   ret = g_hash_table_get_keys (priv->accounts);
 772   g_list_foreach (ret, (GFunc) g_object_ref, NULL);
 773
 774   return ret;
 775 }
 776
 777 /**
 778  * empathy_account_manager_get_connection:
 779  * @manager: a #EmpathyAccountManager
 780  * @account: a #McAccount
 781  *
 782  * Get the connection of the accounts, or NULL if account is offline or the
 783  * connection is not yet ready. This function does not return a new ref.
 784  *
 785  * Returns: the connection of the accounts.
 786  **/
 787 TpConnection *
 788 empathy_account_manager_get_connection (EmpathyAccountManager *manager,
 789                                         McAccount *account)
 790 {
 791   EmpathyAccountManagerPriv *priv;
 792   AccountData *data;
 793
 794   g_return_val_if_fail (EMPATHY_IS_ACCOUNT_MANAGER (manager), NULL);
 795   g_return_val_if_fail (MC_IS_ACCOUNT (account), NULL);
 796
 797   priv = GET_PRIV (manager);
 798
 799   data = g_hash_table_lookup (priv->accounts, account);
 800   if (data && data->connection && tp_connection_is_ready (data->connection))
 801     return data->connection;
 802
 803   return NULL;
 804 }
 805
 806 /**
 807  * empathy_account_manager_dup_connections:
 808  * @manager: a #EmpathyAccountManager
 809  *
 810  * Get a #GList of all ready #TpConnection. The list must be freed with
 811  * g_list_free, and its elements must be unreffed.
 812  *
 813  * Returns: the list of connections
 814  **/
 815 GList *
 816 empathy_account_manager_dup_connections (EmpathyAccountManager *manager)
 817 {
 818   EmpathyAccountManagerPriv *priv;
 819   GHashTableIter iter;
 820   gpointer connection;
 821   GList *ret = NULL;
 822
 823   g_return_val_if_fail (EMPATHY_IS_ACCOUNT_MANAGER (manager), NULL);
 824
 825   priv = GET_PRIV (manager);
 826
 827   g_hash_table_iter_init (&iter, priv->connections);
 828   while (g_hash_table_iter_next (&iter, &connection, NULL))
 829     if (connection != NULL && tp_connection_is_ready (connection))
 830       ret = g_list_prepend (ret, g_object_ref (connection));
 831
 832   return ret;
 833 }
 834