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 GET_PRIV(obj) EMPATHY_GET_PRIV (obj, EmpathyAccountManager)
  30
  31 typedef struct {
  32   McAccountMonitor *monitor;
  33   MissionControl   *mc;
  34
  35   GHashTable       *accounts;
  36   int               connected;
  37   int               connecting;
  38   gboolean          dispose_run;
  39 } EmpathyAccountManagerPriv;
  40
  41 typedef struct {
  42   McPresence presence;
  43   TpConnectionStatus status;
  44   gboolean is_enabled;
  45
  46   guint source_id;
  47 } AccountData;
  48
  49 enum {
  50   ACCOUNT_CREATED,
  51   ACCOUNT_DELETED,
  52   ACCOUNT_ENABLED,
  53   ACCOUNT_DISABLED,
  54   ACCOUNT_CHANGED,
  55   ACCOUNT_CONNECTION_CHANGED,
  56   ACCOUNT_PRESENCE_CHANGED,
  57   LAST_SIGNAL
  58 };
  59
  60 static guint signals[LAST_SIGNAL];
  61 static EmpathyAccountManager *manager_singleton = NULL;
  62
  63 G_DEFINE_TYPE (EmpathyAccountManager, empathy_account_manager, G_TYPE_OBJECT);
  64
  65 static AccountData *
  66 account_data_new (McPresence presence,
  67                   TpConnectionStatus status,
  68                   gboolean is_enabled)
  69 {
  70   AccountData *retval;
  71
  72   retval = g_slice_new0 (AccountData);
  73   retval->presence = presence;
  74   retval->status = status;
  75   retval->is_enabled = is_enabled;
  76   retval->source_id = 0;
  77
  78   return retval;
  79 }
  80
  81 static AccountData *
  82 account_data_new_default (MissionControl *mc,
  83                           McAccount *account)
  84 {
  85   McPresence actual_p;
  86   TpConnectionStatus actual_c;
  87   GError *err = NULL;
  88
  89   actual_p = mission_control_get_presence_actual (mc, &err);
  90   if (err != NULL)
  91     {
  92       actual_p = MC_PRESENCE_UNSET;
  93       g_clear_error (&err);
  94     }
  95
  96   actual_c = mission_control_get_connection_status (mc, account, &err);
  97
  98   if (err != NULL)
  99     {
 100       actual_c = TP_CONNECTION_STATUS_DISCONNECTED;
 101       g_error_free (err);
 102     }
 103
 104   return account_data_new (actual_p, actual_c, mc_account_is_enabled (account));
 105 }
 106
 107 static void
 108 account_data_free (AccountData *data)
 109 {
 110   if (data->source_id > 0)
 111     {
 112       g_source_remove (data->source_id);
 113       data->source_id = 0;
 114     }
 115
 116   g_slice_free (AccountData, data);
 117 }
 118
 119 static void
 120 account_created_cb (McAccountMonitor *mon,
 121                     gchar *account_name,
 122                     EmpathyAccountManager *manager)
 123 {
 124   McAccount *account;
 125   EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
 126   TpConnectionStatus initial_status;
 127
 128   account = mc_account_lookup (account_name);
 129
 130   if (account)
 131     {
 132       AccountData *data;
 133
 134       data = account_data_new_default (priv->mc, account);
 135
 136       initial_status = mission_control_get_connection_status (priv->mc,
 137                                                               account, NULL);
 138
 139       if (initial_status == TP_CONNECTION_STATUS_CONNECTED)
 140         priv->connected++;
 141       else if (initial_status == TP_CONNECTION_STATUS_CONNECTING)
 142         priv->connecting++;
 143
 144       /* the reference returned by mc_account_lookup is owned by the
 145        * hash table.
 146        */
 147       g_hash_table_insert (priv->accounts, account, data);
 148
 149       g_signal_emit (manager, signals[ACCOUNT_CREATED], 0, account);
 150     }
 151 }
 152
 153 static void
 154 account_deleted_cb (McAccountMonitor *mon,
 155                     gchar *account_name,
 156                     EmpathyAccountManager *manager)
 157 {
 158   McAccount *account;
 159   EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
 160
 161   account = mc_account_lookup (account_name);
 162
 163   if (account)
 164     {
 165       g_hash_table_remove (priv->accounts, account);
 166       g_signal_emit (manager, signals[ACCOUNT_DELETED], 0, account);
 167       g_object_unref (account);
 168     }
 169 }
 170
 171 static void
 172 account_changed_cb (McAccountMonitor *mon,
 173                     gchar *account_name,
 174                     EmpathyAccountManager *manager)
 175 {
 176   McAccount *account;
 177
 178   account = mc_account_lookup (account_name);
 179
 180   if (account)
 181     {
 182       g_signal_emit (manager, signals[ACCOUNT_CHANGED], 0, account);
 183       g_object_unref (account);
 184     }
 185 }
 186
 187 static void
 188 account_disabled_cb (McAccountMonitor *mon,
 189                      gchar *account_name,
 190                      EmpathyAccountManager *manager)
 191 {
 192   McAccount *account;
 193   EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
 194   AccountData *data;
 195
 196   account = mc_account_lookup (account_name);
 197
 198   if (account)
 199     {
 200       data = g_hash_table_lookup (priv->accounts, account);
 201       g_assert (data);
 202       data->is_enabled = FALSE;
 203
 204       g_signal_emit (manager, signals[ACCOUNT_DISABLED], 0, account);
 205       g_object_unref (account);
 206     }
 207 }
 208
 209 static void
 210 account_enabled_cb (McAccountMonitor *mon,
 211                     gchar *account_name,
 212                     EmpathyAccountManager *manager)
 213 {
 214   McAccount *account;
 215   EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
 216   AccountData *data;
 217
 218   account = mc_account_lookup (account_name);
 219
 220   if (account)
 221     {
 222       data = g_hash_table_lookup (priv->accounts, account);
 223       g_assert (data);
 224       data->is_enabled = TRUE;
 225
 226       g_signal_emit (manager, signals[ACCOUNT_ENABLED], 0, account);
 227       g_object_unref (account);
 228     }
 229 }
 230
 231 static void
 232 update_connection_numbers (EmpathyAccountManager *manager,
 233                            TpConnectionStatus status,
 234                            TpConnectionStatus old_s)
 235 {
 236   EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
 237
 238   if (status == TP_CONNECTION_STATUS_CONNECTED)
 239     {
 240       priv->connected++;
 241       if (old_s == TP_CONNECTION_STATUS_CONNECTING)
 242         priv->connecting--;
 243     }
 244
 245   if (status == TP_CONNECTION_STATUS_CONNECTING)
 246     {
 247       priv->connecting++;
 248       if (old_s == TP_CONNECTION_STATUS_CONNECTED)
 249         priv->connected--;
 250     }
 251
 252   if (status == TP_CONNECTION_STATUS_DISCONNECTED)
 253     {
 254       if (old_s == TP_CONNECTION_STATUS_CONNECTED)
 255         priv->connected--;
 256
 257       if (old_s == TP_CONNECTION_STATUS_CONNECTING)
 258         priv->connecting--;
 259     }
 260 }
 261
 262 static gboolean
 263 remove_data_timeout (gpointer _data)
 264 {
 265   AccountData *data = _data;
 266
 267   data->source_id = 0;
 268
 269   return FALSE;
 270 }
 271
 272 typedef struct {
 273   TpConnectionStatus status;
 274   McPresence presence;
 275   TpConnectionStatusReason reason;
 276   gchar *unique_name;
 277   EmpathyAccountManager *manager;
 278 } ChangedSignalData;
 279
 280 static gboolean
 281 account_status_changed_idle_cb (ChangedSignalData *signal_data)
 282 {
 283   McAccount *account;
 284   AccountData *data;
 285   McPresence presence, old_p;
 286   TpConnectionStatus status, old_s;
 287   gboolean emit_presence = FALSE, emit_connection = FALSE;
 288   EmpathyAccountManager *manager = signal_data->manager;
 289   EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
 290
 291   presence = signal_data->presence;
 292   status = signal_data->status;
 293   account = mc_account_lookup (signal_data->unique_name);
 294
 295   if (account)
 296     {
 297       data = g_hash_table_lookup (priv->accounts, account);
 298       g_assert (data);
 299
 300       old_p = data->presence;
 301       old_s = data->status;
 302
 303       if (old_p != presence)
 304         {
 305           data->presence = presence;
 306           emit_presence = TRUE;
 307         }
 308
 309       if (old_s != status)
 310         {
 311           data->status = status;
 312           update_connection_numbers (manager, status, old_s);
 313
 314           if (status == TP_CONNECTION_STATUS_CONNECTED)
 315             {
 316                 if (data->source_id > 0) {
 317                   g_source_remove (data->source_id);
 318                   data->source_id = 0;
 319                 }
 320
 321                 data->source_id = g_timeout_add_seconds (10,
 322                                                          remove_data_timeout,
 323                                                          data);
 324             }
 325           emit_connection = TRUE;
 326         }
 327
 328       if (emit_presence)
 329         g_signal_emit (manager, signals[ACCOUNT_PRESENCE_CHANGED], 0,
 330                        account, presence, old_p);
 331
 332       if (emit_connection)
 333         g_signal_emit (manager, signals[ACCOUNT_CONNECTION_CHANGED], 0,
 334                        account, signal_data->reason, status, old_s);
 335
 336       g_object_unref (account);
 337     }
 338
 339   g_object_unref (signal_data->manager);
 340   g_free (signal_data->unique_name);
 341   g_slice_free (ChangedSignalData, signal_data);
 342
 343   return FALSE;
 344 }
 345
 346 static void
 347 account_status_changed_cb (MissionControl *mc,
 348                            TpConnectionStatus status,
 349                            McPresence presence,
 350                            TpConnectionStatusReason reason,
 351                            const gchar *unique_name,
 352                            EmpathyAccountManager *manager)
 353 {
 354   ChangedSignalData *data;
 355
 356   data = g_slice_new0 (ChangedSignalData);
 357   data->status = status;
 358   data->presence = presence;
 359   data->reason = reason;
 360   data->unique_name = g_strdup (unique_name);
 361   data->manager = g_object_ref (manager);
 362
 363   g_idle_add ((GSourceFunc) account_status_changed_idle_cb, data);
 364 }
 365
 366 static void
 367 empathy_account_manager_init (EmpathyAccountManager *manager)
 368 {
 369   EmpathyAccountManagerPriv *priv;
 370   GList *mc_accounts, *l;
 371   AccountData *data;
 372
 373   priv = G_TYPE_INSTANCE_GET_PRIVATE (manager,
 374                                       EMPATHY_TYPE_ACCOUNT_MANAGER, EmpathyAccountManagerPriv);
 375   manager->priv = priv;
 376   priv->monitor = mc_account_monitor_new ();
 377   priv->mc = empathy_mission_control_dup_singleton ();
 378   priv->connected = priv->connecting = 0;
 379   priv->dispose_run = FALSE;
 380
 381   priv->accounts = g_hash_table_new_full (empathy_account_hash,
 382                                           empathy_account_equal,
 383                                           g_object_unref,
 384                                           (GDestroyNotify) account_data_free);
 385
 386   mc_accounts = mc_accounts_list ();
 387
 388   for (l = mc_accounts; l; l = l->next)
 389     {
 390       data = account_data_new_default (priv->mc, l->data);
 391
 392       account_created_cb (priv->monitor, (char *) mc_account_get_unique_name (l->data), manager);
 393     }
 394
 395   g_signal_connect (priv->monitor, "account-created",
 396                     G_CALLBACK (account_created_cb), manager);
 397   g_signal_connect (priv->monitor, "account-deleted",
 398                     G_CALLBACK (account_deleted_cb), manager);
 399   g_signal_connect (priv->monitor, "account-disabled",
 400                     G_CALLBACK (account_disabled_cb), manager);
 401   g_signal_connect (priv->monitor, "account-enabled",
 402                     G_CALLBACK (account_enabled_cb), manager);
 403   g_signal_connect (priv->monitor, "account-changed",
 404                     G_CALLBACK (account_changed_cb), manager);
 405
 406   dbus_g_proxy_connect_signal (DBUS_G_PROXY (priv->mc), "AccountStatusChanged",
 407                                G_CALLBACK (account_status_changed_cb),
 408                                manager, NULL);
 409
 410   mc_accounts_list_free (mc_accounts);
 411 }
 412
 413 static void
 414 do_finalize (GObject *obj)
 415 {
 416   EmpathyAccountManager *manager = EMPATHY_ACCOUNT_MANAGER (obj);
 417   EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
 418
 419   g_hash_table_unref (priv->accounts);
 420
 421   G_OBJECT_CLASS (empathy_account_manager_parent_class)->finalize (obj);
 422 }
 423
 424 static void
 425 do_dispose (GObject *obj)
 426 {
 427   EmpathyAccountManager *manager = EMPATHY_ACCOUNT_MANAGER (obj);
 428   EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
 429
 430   if (priv->dispose_run)
 431     return;
 432
 433   priv->dispose_run = TRUE;
 434
 435   dbus_g_proxy_disconnect_signal (DBUS_G_PROXY (priv->mc),
 436                                   "AccountStatusChanged",
 437                                   G_CALLBACK (account_status_changed_cb),
 438                                   obj);
 439
 440   if (priv->monitor)
 441     {
 442       g_signal_handlers_disconnect_by_func (priv->monitor,
 443                                             account_created_cb, obj);
 444       g_signal_handlers_disconnect_by_func (priv->monitor,
 445                                             account_deleted_cb, obj);
 446       g_signal_handlers_disconnect_by_func (priv->monitor,
 447                                             account_disabled_cb, obj);
 448       g_signal_handlers_disconnect_by_func (priv->monitor,
 449                                             account_enabled_cb, obj);
 450       g_signal_handlers_disconnect_by_func (priv->monitor,
 451                                             account_changed_cb, obj);
 452       g_object_unref (priv->monitor);
 453       priv->monitor = NULL;
 454     }
 455
 456   if (priv->mc)
 457     g_object_unref (priv->mc);
 458
 459   g_hash_table_remove_all (priv->accounts);
 460
 461   G_OBJECT_CLASS (empathy_account_manager_parent_class)->dispose (obj);
 462 }
 463
 464 static GObject*
 465 do_constructor (GType type,
 466                 guint n_construct_params,
 467                 GObjectConstructParam *construct_params)
 468 {
 469   GObject *retval;
 470
 471   if (!manager_singleton)
 472     {
 473       retval = G_OBJECT_CLASS (empathy_account_manager_parent_class)->constructor (type,
 474                                                                                    n_construct_params,
 475                                                                                    construct_params);
 476       manager_singleton = EMPATHY_ACCOUNT_MANAGER (retval);
 477       g_object_add_weak_pointer (retval, (gpointer) &manager_singleton);
 478     }
 479   else
 480     {
 481       retval = g_object_ref (manager_singleton);
 482     }
 483
 484   return retval;
 485 }
 486
 487 static void
 488 empathy_account_manager_class_init (EmpathyAccountManagerClass *klass)
 489 {
 490   GObjectClass *oclass = G_OBJECT_CLASS (klass);
 491
 492   oclass->finalize = do_finalize;
 493   oclass->dispose = do_dispose;
 494   oclass->constructor = do_constructor;
 495
 496   signals[ACCOUNT_CREATED] =
 497     g_signal_new ("account-created",
 498                   G_TYPE_FROM_CLASS (klass),
 499                   G_SIGNAL_RUN_LAST,
 500                   0,
 501                   NULL, NULL,
 502                   g_cclosure_marshal_VOID__OBJECT,
 503                   G_TYPE_NONE,
 504                   1, MC_TYPE_ACCOUNT);
 505
 506   signals[ACCOUNT_DELETED] =
 507     g_signal_new ("account-deleted",
 508                   G_TYPE_FROM_CLASS (klass),
 509                   G_SIGNAL_RUN_LAST,
 510                   0,
 511                   NULL, NULL,
 512                   g_cclosure_marshal_VOID__OBJECT,
 513                   G_TYPE_NONE,
 514                   1, MC_TYPE_ACCOUNT);
 515
 516   signals[ACCOUNT_ENABLED] =
 517     g_signal_new ("account-enabled",
 518                   G_TYPE_FROM_CLASS (klass),
 519                   G_SIGNAL_RUN_LAST,
 520                   0,
 521                   NULL, NULL,
 522                   g_cclosure_marshal_VOID__OBJECT,
 523                   G_TYPE_NONE,
 524                   1, MC_TYPE_ACCOUNT);
 525
 526   signals[ACCOUNT_DISABLED] =
 527     g_signal_new ("account-disabled",
 528                   G_TYPE_FROM_CLASS (klass),
 529                   G_SIGNAL_RUN_LAST,
 530                   0,
 531                   NULL, NULL,
 532                   g_cclosure_marshal_VOID__OBJECT,
 533                   G_TYPE_NONE,
 534                   1, MC_TYPE_ACCOUNT);
 535
 536   signals[ACCOUNT_CHANGED] =
 537     g_signal_new ("account-changed",
 538                   G_TYPE_FROM_CLASS (klass),
 539                   G_SIGNAL_RUN_LAST,
 540                   0,
 541                   NULL, NULL,
 542                   g_cclosure_marshal_VOID__OBJECT,
 543                   G_TYPE_NONE,
 544                   1, MC_TYPE_ACCOUNT);
 545
 546   signals[ACCOUNT_CONNECTION_CHANGED] =
 547     g_signal_new ("account-connection-changed",
 548                   G_TYPE_FROM_CLASS (klass),
 549                   G_SIGNAL_RUN_LAST,
 550                   0,
 551                   NULL, NULL,
 552                   _empathy_marshal_VOID__OBJECT_INT_UINT_UINT,
 553                   G_TYPE_NONE,
 554                   4, MC_TYPE_ACCOUNT,
 555                   G_TYPE_INT,   /* reason */
 556                   G_TYPE_UINT,  /* actual connection */
 557                   G_TYPE_UINT); /* previous connection */
 558
 559   signals[ACCOUNT_PRESENCE_CHANGED] =
 560     g_signal_new ("account-presence-changed",
 561                   G_TYPE_FROM_CLASS (klass),
 562                   G_SIGNAL_RUN_LAST,
 563                   0,
 564                   NULL, NULL,
 565                   _empathy_marshal_VOID__OBJECT_INT_INT,
 566                   G_TYPE_NONE,
 567                   3, MC_TYPE_ACCOUNT,
 568                   G_TYPE_INT,  /* actual presence */
 569                   G_TYPE_INT); /* previous presence */
 570
 571   g_type_class_add_private (oclass, sizeof (EmpathyAccountManagerPriv));
 572 }
 573
 574 /* public methods */
 575
 576 EmpathyAccountManager *
 577 empathy_account_manager_dup_singleton (void)
 578 {
 579   return g_object_new (EMPATHY_TYPE_ACCOUNT_MANAGER, NULL);
 580 }
 581
 582 int
 583 empathy_account_manager_get_connected_accounts (EmpathyAccountManager *manager)
 584 {
 585   EmpathyAccountManagerPriv *priv;
 586
 587   g_return_val_if_fail (EMPATHY_IS_ACCOUNT_MANAGER (manager), 0);
 588
 589   priv = GET_PRIV (manager);
 590
 591   return priv->connected;
 592 }
 593
 594 int
 595 empathy_account_manager_get_connecting_accounts (EmpathyAccountManager *manager)
 596 {
 597   EmpathyAccountManagerPriv *priv;
 598
 599   g_return_val_if_fail (EMPATHY_IS_ACCOUNT_MANAGER (manager), 0);
 600
 601   priv = GET_PRIV (manager);
 602
 603   return priv->connecting;
 604 }
 605
 606 gboolean
 607 empathy_account_manager_is_account_just_connected (EmpathyAccountManager *manager,
 608                                                    McAccount *account)
 609 {
 610   EmpathyAccountManagerPriv *priv;
 611   AccountData *data;
 612
 613   g_return_val_if_fail (EMPATHY_IS_ACCOUNT_MANAGER (manager), FALSE);
 614
 615   priv = GET_PRIV (manager);
 616   data = g_hash_table_lookup (priv->accounts, account);
 617
 618   g_assert (data);
 619
 620   return (data->source_id > 0);
 621 }
 622
 623 /**
 624  * empathy_account_manager_get_count:
 625  * @manager: a #EmpathyAccountManager
 626  *
 627  * Get the number of accounts.
 628  *
 629  * Returns: the number of accounts.
 630  **/
 631 int
 632 empathy_account_manager_get_count (EmpathyAccountManager *manager)
 633 {
 634   EmpathyAccountManagerPriv *priv;
 635
 636   g_return_val_if_fail (EMPATHY_IS_ACCOUNT_MANAGER (manager), 0);
 637
 638   priv = GET_PRIV (manager);
 639
 640   return g_hash_table_size (priv->accounts);
 641 }