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 account_manager_disconnect_foreach (gpointer key,
 509                                     gpointer value,
 510                                     gpointer user_data)
 511 {
 512   TpConnection *connection = key;
 513   EmpathyAccountManager *manager = user_data;
 514
 515   g_signal_handlers_disconnect_by_func (connection, connection_invalidated_cb,
 516     manager);
 517 }
 518
 519 static void
 520 do_finalize (GObject *obj)
 521 {
 522   EmpathyAccountManager *manager = EMPATHY_ACCOUNT_MANAGER (obj);
 523   EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
 524
 525   g_hash_table_unref (priv->accounts);
 526   g_hash_table_foreach (priv->connections, account_manager_disconnect_foreach,
 527     obj);
 528   g_hash_table_unref (priv->connections);
 529
 530   G_OBJECT_CLASS (empathy_account_manager_parent_class)->finalize (obj);
 531 }
 532
 533 static void
 534 do_dispose (GObject *obj)
 535 {
 536   EmpathyAccountManager *manager = EMPATHY_ACCOUNT_MANAGER (obj);
 537   EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
 538
 539   if (priv->dispose_run)
 540     return;
 541
 542   priv->dispose_run = TRUE;
 543
 544   dbus_g_proxy_disconnect_signal (DBUS_G_PROXY (priv->mc),
 545                                   "AccountStatusChanged",
 546                                   G_CALLBACK (account_status_changed_cb),
 547                                   obj);
 548
 549   if (priv->monitor)
 550     {
 551       g_signal_handlers_disconnect_by_func (priv->monitor,
 552                                             account_created_cb, obj);
 553       g_signal_handlers_disconnect_by_func (priv->monitor,
 554                                             account_deleted_cb, obj);
 555       g_signal_handlers_disconnect_by_func (priv->monitor,
 556                                             account_disabled_cb, obj);
 557       g_signal_handlers_disconnect_by_func (priv->monitor,
 558                                             account_enabled_cb, obj);
 559       g_signal_handlers_disconnect_by_func (priv->monitor,
 560                                             account_changed_cb, obj);
 561       g_object_unref (priv->monitor);
 562       priv->monitor = NULL;
 563     }
 564
 565   if (priv->mc)
 566     g_object_unref (priv->mc);
 567
 568   g_hash_table_remove_all (priv->accounts);
 569
 570   G_OBJECT_CLASS (empathy_account_manager_parent_class)->dispose (obj);
 571 }
 572
 573 static GObject *
 574 do_constructor (GType type,
 575                 guint n_construct_params,
 576                 GObjectConstructParam *construct_params)
 577 {
 578   GObject *retval;
 579
 580   if (!manager_singleton)
 581     {
 582       retval = G_OBJECT_CLASS (empathy_account_manager_parent_class)->constructor (type,
 583                                                                                    n_construct_params,
 584                                                                                    construct_params);
 585       manager_singleton = EMPATHY_ACCOUNT_MANAGER (retval);
 586       g_object_add_weak_pointer (retval, (gpointer) &manager_singleton);
 587     }
 588   else
 589     {
 590       retval = g_object_ref (manager_singleton);
 591     }
 592
 593   return retval;
 594 }
 595
 596 static void
 597 empathy_account_manager_class_init (EmpathyAccountManagerClass *klass)
 598 {
 599   GObjectClass *oclass = G_OBJECT_CLASS (klass);
 600
 601   oclass->finalize = do_finalize;
 602   oclass->dispose = do_dispose;
 603   oclass->constructor = do_constructor;
 604
 605   signals[ACCOUNT_CREATED] =
 606     g_signal_new ("account-created",
 607                   G_TYPE_FROM_CLASS (klass),
 608                   G_SIGNAL_RUN_LAST,
 609                   0,
 610                   NULL, NULL,
 611                   g_cclosure_marshal_VOID__OBJECT,
 612                   G_TYPE_NONE,
 613                   1, MC_TYPE_ACCOUNT);
 614
 615   signals[ACCOUNT_DELETED] =
 616     g_signal_new ("account-deleted",
 617                   G_TYPE_FROM_CLASS (klass),
 618                   G_SIGNAL_RUN_LAST,
 619                   0,
 620                   NULL, NULL,
 621                   g_cclosure_marshal_VOID__OBJECT,
 622                   G_TYPE_NONE,
 623                   1, MC_TYPE_ACCOUNT);
 624
 625   signals[ACCOUNT_ENABLED] =
 626     g_signal_new ("account-enabled",
 627                   G_TYPE_FROM_CLASS (klass),
 628                   G_SIGNAL_RUN_LAST,
 629                   0,
 630                   NULL, NULL,
 631                   g_cclosure_marshal_VOID__OBJECT,
 632                   G_TYPE_NONE,
 633                   1, MC_TYPE_ACCOUNT);
 634
 635   signals[ACCOUNT_DISABLED] =
 636     g_signal_new ("account-disabled",
 637                   G_TYPE_FROM_CLASS (klass),
 638                   G_SIGNAL_RUN_LAST,
 639                   0,
 640                   NULL, NULL,
 641                   g_cclosure_marshal_VOID__OBJECT,
 642                   G_TYPE_NONE,
 643                   1, MC_TYPE_ACCOUNT);
 644
 645   signals[ACCOUNT_CHANGED] =
 646     g_signal_new ("account-changed",
 647                   G_TYPE_FROM_CLASS (klass),
 648                   G_SIGNAL_RUN_LAST,
 649                   0,
 650                   NULL, NULL,
 651                   g_cclosure_marshal_VOID__OBJECT,
 652                   G_TYPE_NONE,
 653                   1, MC_TYPE_ACCOUNT);
 654
 655   signals[ACCOUNT_CONNECTION_CHANGED] =
 656     g_signal_new ("account-connection-changed",
 657                   G_TYPE_FROM_CLASS (klass),
 658                   G_SIGNAL_RUN_LAST,
 659                   0,
 660                   NULL, NULL,
 661                   _empathy_marshal_VOID__OBJECT_INT_UINT_UINT,
 662                   G_TYPE_NONE,
 663                   4, MC_TYPE_ACCOUNT,
 664                   G_TYPE_INT,   /* reason */
 665                   G_TYPE_UINT,  /* actual connection */
 666                   G_TYPE_UINT); /* previous connection */
 667
 668   signals[ACCOUNT_PRESENCE_CHANGED] =
 669     g_signal_new ("account-presence-changed",
 670                   G_TYPE_FROM_CLASS (klass),
 671                   G_SIGNAL_RUN_LAST,
 672                   0,
 673                   NULL, NULL,
 674                   _empathy_marshal_VOID__OBJECT_INT_INT,
 675                   G_TYPE_NONE,
 676                   3, MC_TYPE_ACCOUNT,
 677                   G_TYPE_INT,  /* actual presence */
 678                   G_TYPE_INT); /* previous presence */
 679
 680   signals[NEW_CONNECTION] =
 681     g_signal_new ("new-connection",
 682                   G_TYPE_FROM_CLASS (klass),
 683                   G_SIGNAL_RUN_LAST,
 684                   0,
 685                   NULL, NULL,
 686                   g_cclosure_marshal_VOID__OBJECT,
 687                   G_TYPE_NONE,
 688                   1, TP_TYPE_CONNECTION);
 689
 690   g_type_class_add_private (oclass, sizeof (EmpathyAccountManagerPriv));
 691 }
 692
 693 /* public methods */
 694
 695 EmpathyAccountManager *
 696 empathy_account_manager_dup_singleton (void)
 697 {
 698   return g_object_new (EMPATHY_TYPE_ACCOUNT_MANAGER, NULL);
 699 }
 700
 701 int
 702 empathy_account_manager_get_connected_accounts (EmpathyAccountManager *manager)
 703 {
 704   EmpathyAccountManagerPriv *priv;
 705
 706   g_return_val_if_fail (EMPATHY_IS_ACCOUNT_MANAGER (manager), 0);
 707
 708   priv = GET_PRIV (manager);
 709
 710   return priv->connected;
 711 }
 712
 713 int
 714 empathy_account_manager_get_connecting_accounts (EmpathyAccountManager *manager)
 715 {
 716   EmpathyAccountManagerPriv *priv;
 717
 718   g_return_val_if_fail (EMPATHY_IS_ACCOUNT_MANAGER (manager), 0);
 719
 720   priv = GET_PRIV (manager);
 721
 722   return priv->connecting;
 723 }
 724
 725 gboolean
 726 empathy_account_manager_is_account_just_connected (EmpathyAccountManager *manager,
 727                                                    McAccount *account)
 728 {
 729   EmpathyAccountManagerPriv *priv;
 730   AccountData *data;
 731
 732   g_return_val_if_fail (EMPATHY_IS_ACCOUNT_MANAGER (manager), FALSE);
 733
 734   priv = GET_PRIV (manager);
 735   data = g_hash_table_lookup (priv->accounts, account);
 736
 737   g_assert (data);
 738
 739   return (data->source_id > 0);
 740 }
 741
 742 /**
 743  * empathy_account_manager_get_count:
 744  * @manager: a #EmpathyAccountManager
 745  *
 746  * Get the number of accounts.
 747  *
 748  * Returns: the number of accounts.
 749  **/
 750 int
 751 empathy_account_manager_get_count (EmpathyAccountManager *manager)
 752 {
 753   EmpathyAccountManagerPriv *priv;
 754
 755   g_return_val_if_fail (EMPATHY_IS_ACCOUNT_MANAGER (manager), 0);
 756
 757   priv = GET_PRIV (manager);
 758
 759   return g_hash_table_size (priv->accounts);
 760 }
 761
 762 McAccount *
 763 empathy_account_manager_get_account (EmpathyAccountManager *manager,
 764                                      TpConnection          *connection)
 765 {
 766   EmpathyAccountManagerPriv *priv;
 767
 768   g_return_val_if_fail (EMPATHY_IS_ACCOUNT_MANAGER (manager), 0);
 769
 770   priv = GET_PRIV (manager);
 771
 772   return g_hash_table_lookup (priv->connections, connection);
 773 }
 774
 775 GList *
 776 empathy_account_manager_dup_accounts (EmpathyAccountManager *manager)
 777 {
 778   EmpathyAccountManagerPriv *priv;
 779   GList *ret;
 780
 781   g_return_val_if_fail (EMPATHY_IS_ACCOUNT_MANAGER (manager), NULL);
 782
 783   priv = GET_PRIV (manager);
 784
 785   ret = g_hash_table_get_keys (priv->accounts);
 786   g_list_foreach (ret, (GFunc) g_object_ref, NULL);
 787
 788   return ret;
 789 }
 790
 791 /**
 792  * empathy_account_manager_get_connection:
 793  * @manager: a #EmpathyAccountManager
 794  * @account: a #McAccount
 795  *
 796  * Get the connection of the accounts, or NULL if account is offline or the
 797  * connection is not yet ready. This function does not return a new ref.
 798  *
 799  * Returns: the connection of the accounts.
 800  **/
 801 TpConnection *
 802 empathy_account_manager_get_connection (EmpathyAccountManager *manager,
 803                                         McAccount *account)
 804 {
 805   EmpathyAccountManagerPriv *priv;
 806   AccountData *data;
 807
 808   g_return_val_if_fail (EMPATHY_IS_ACCOUNT_MANAGER (manager), NULL);
 809   g_return_val_if_fail (MC_IS_ACCOUNT (account), NULL);
 810
 811   priv = GET_PRIV (manager);
 812
 813   data = g_hash_table_lookup (priv->accounts, account);
 814   if (data && data->connection && tp_connection_is_ready (data->connection))
 815     return data->connection;
 816
 817   return NULL;
 818 }
 819
 820 /**
 821  * empathy_account_manager_dup_connections:
 822  * @manager: a #EmpathyAccountManager
 823  *
 824  * Get a #GList of all ready #TpConnection. The list must be freed with
 825  * g_list_free, and its elements must be unreffed.
 826  *
 827  * Returns: the list of connections
 828  **/
 829 GList *
 830 empathy_account_manager_dup_connections (EmpathyAccountManager *manager)
 831 {
 832   EmpathyAccountManagerPriv *priv;
 833   GHashTableIter iter;
 834   gpointer connection;
 835   GList *ret = NULL;
 836
 837   g_return_val_if_fail (EMPATHY_IS_ACCOUNT_MANAGER (manager), NULL);
 838
 839   priv = GET_PRIV (manager);
 840
 841   g_hash_table_iter_init (&iter, priv->connections);
 842   while (g_hash_table_iter_next (&iter, &connection, NULL))
 843     if (connection != NULL && tp_connection_is_ready (connection))
 844       ret = g_list_prepend (ret, g_object_ref (connection));
 845
 846   return ret;
 847 }
 848