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_signal_emit (manager, signals[ACCOUNT_DELETED], 0, account);
 166
 167       g_hash_table_remove (priv->accounts, account);
 168       g_object_unref (account);
 169     }
 170 }
 171
 172 static void
 173 account_changed_cb (McAccountMonitor *mon,
 174                     gchar *account_name,
 175                     EmpathyAccountManager *manager)
 176 {
 177   McAccount *account;
 178
 179   account = mc_account_lookup (account_name);
 180
 181   if (account)
 182     {
 183       g_signal_emit (manager, signals[ACCOUNT_CHANGED], 0, account);
 184       g_object_unref (account);
 185     }
 186 }
 187
 188 static void
 189 account_disabled_cb (McAccountMonitor *mon,
 190                      gchar *account_name,
 191                      EmpathyAccountManager *manager)
 192 {
 193   McAccount *account;
 194   EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
 195   AccountData *data;
 196
 197   account = mc_account_lookup (account_name);
 198
 199   if (account)
 200     {
 201       data = g_hash_table_lookup (priv->accounts, account);
 202       g_assert (data);
 203       data->is_enabled = FALSE;
 204
 205       g_signal_emit (manager, signals[ACCOUNT_DISABLED], 0, account);
 206       g_object_unref (account);
 207     }
 208 }
 209
 210 static void
 211 account_enabled_cb (McAccountMonitor *mon,
 212                     gchar *account_name,
 213                     EmpathyAccountManager *manager)
 214 {
 215   McAccount *account;
 216   EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
 217   AccountData *data;
 218
 219   account = mc_account_lookup (account_name);
 220
 221   if (account)
 222     {
 223       data = g_hash_table_lookup (priv->accounts, account);
 224       g_assert (data);
 225       data->is_enabled = TRUE;
 226
 227       g_signal_emit (manager, signals[ACCOUNT_ENABLED], 0, account);
 228       g_object_unref (account);
 229     }
 230 }
 231
 232 static void
 233 update_connection_numbers (EmpathyAccountManager *manager,
 234                            TpConnectionStatus status,
 235                            TpConnectionStatus old_s)
 236 {
 237   EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
 238
 239   if (status == TP_CONNECTION_STATUS_CONNECTED)
 240     {
 241       priv->connected++;
 242       if (old_s == TP_CONNECTION_STATUS_CONNECTING)
 243         priv->connecting--;
 244     }
 245
 246   if (status == TP_CONNECTION_STATUS_CONNECTING)
 247     {
 248       priv->connecting++;
 249       if (old_s == TP_CONNECTION_STATUS_CONNECTED)
 250         priv->connected--;
 251     }
 252
 253   if (status == TP_CONNECTION_STATUS_DISCONNECTED)
 254     {
 255       if (old_s == TP_CONNECTION_STATUS_CONNECTED)
 256         priv->connected--;
 257
 258       if (old_s == TP_CONNECTION_STATUS_CONNECTING)
 259         priv->connecting--;
 260     }
 261 }
 262
 263 static gboolean
 264 remove_data_timeout (gpointer _data)
 265 {
 266   AccountData *data = _data;
 267
 268   data->source_id = 0;
 269
 270   return FALSE;
 271 }
 272
 273 typedef struct {
 274   TpConnectionStatus status;
 275   McPresence presence;
 276   TpConnectionStatusReason reason;
 277   gchar *unique_name;
 278   EmpathyAccountManager *manager;
 279 } ChangedSignalData;
 280
 281 static gboolean
 282 account_status_changed_idle_cb (ChangedSignalData *signal_data)
 283 {
 284   McAccount *account;
 285   AccountData *data;
 286   McPresence presence, old_p;
 287   TpConnectionStatus status, old_s;
 288   gboolean emit_presence = FALSE, emit_connection = FALSE;
 289   EmpathyAccountManager *manager = signal_data->manager;
 290   EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
 291
 292   presence = signal_data->presence;
 293   status = signal_data->status;
 294   account = mc_account_lookup (signal_data->unique_name);
 295
 296   if (account)
 297     {
 298       data = g_hash_table_lookup (priv->accounts, account);
 299       g_assert (data);
 300
 301       old_p = data->presence;
 302       old_s = data->status;
 303
 304       if (old_p != presence)
 305         {
 306           data->presence = presence;
 307           emit_presence = TRUE;
 308         }
 309
 310       if (old_s != status)
 311         {
 312           data->status = status;
 313           update_connection_numbers (manager, status, old_s);
 314
 315           if (status == TP_CONNECTION_STATUS_CONNECTED)
 316             {
 317                 if (data->source_id > 0) {
 318                   g_source_remove (data->source_id);
 319                   data->source_id = 0;
 320                 }
 321
 322                 data->source_id = g_timeout_add_seconds (10,
 323                                                          remove_data_timeout,
 324                                                          data);
 325             }
 326           emit_connection = TRUE;
 327         }
 328
 329       if (emit_presence)
 330         g_signal_emit (manager, signals[ACCOUNT_PRESENCE_CHANGED], 0,
 331                        account, presence, old_p);
 332
 333       if (emit_connection)
 334         g_signal_emit (manager, signals[ACCOUNT_CONNECTION_CHANGED], 0,
 335                        account, signal_data->reason, status, old_s);
 336
 337       g_object_unref (account);
 338     }
 339
 340   g_object_unref (signal_data->manager);
 341   g_free (signal_data->unique_name);
 342   g_slice_free (ChangedSignalData, signal_data);
 343
 344   return FALSE;
 345 }
 346
 347 static void
 348 account_status_changed_cb (MissionControl *mc,
 349                            TpConnectionStatus status,
 350                            McPresence presence,
 351                            TpConnectionStatusReason reason,
 352                            const gchar *unique_name,
 353                            EmpathyAccountManager *manager)
 354 {
 355   ChangedSignalData *data;
 356
 357   data = g_slice_new0 (ChangedSignalData);
 358   data->status = status;
 359   data->presence = presence;
 360   data->reason = reason;
 361   data->unique_name = g_strdup (unique_name);
 362   data->manager = g_object_ref (manager);
 363
 364   g_idle_add ((GSourceFunc) account_status_changed_idle_cb, data);
 365 }
 366
 367 static void
 368 empathy_account_manager_init (EmpathyAccountManager *manager)
 369 {
 370   EmpathyAccountManagerPriv *priv;
 371   GList *mc_accounts, *l;
 372   AccountData *data;
 373
 374   priv = G_TYPE_INSTANCE_GET_PRIVATE (manager,
 375                                       EMPATHY_TYPE_ACCOUNT_MANAGER, EmpathyAccountManagerPriv);
 376   manager->priv = priv;
 377   priv->monitor = mc_account_monitor_new ();
 378   priv->mc = empathy_mission_control_new ();
 379   priv->connected = priv->connecting = 0;
 380   priv->dispose_run = FALSE;
 381
 382   priv->accounts = g_hash_table_new_full (empathy_account_hash,
 383                                           empathy_account_equal,
 384                                           g_object_unref,
 385                                           (GDestroyNotify) account_data_free);
 386
 387   mc_accounts = mc_accounts_list ();
 388
 389   for (l = mc_accounts; l; l = l->next)
 390     {
 391       data = account_data_new_default (priv->mc, l->data);
 392
 393       account_created_cb (priv->monitor, (char *) mc_account_get_unique_name (l->data), manager);
 394     }
 395
 396   g_signal_connect (priv->monitor, "account-created",
 397                     G_CALLBACK (account_created_cb), manager);
 398   g_signal_connect (priv->monitor, "account-deleted",
 399                     G_CALLBACK (account_deleted_cb), manager);
 400   g_signal_connect (priv->monitor, "account-disabled",
 401                     G_CALLBACK (account_disabled_cb), manager);
 402   g_signal_connect (priv->monitor, "account-enabled",
 403                     G_CALLBACK (account_enabled_cb), manager);
 404   g_signal_connect (priv->monitor, "account-changed",
 405                     G_CALLBACK (account_changed_cb), manager);
 406
 407   dbus_g_proxy_connect_signal (DBUS_G_PROXY (priv->mc), "AccountStatusChanged",
 408                                G_CALLBACK (account_status_changed_cb),
 409                                manager, NULL);
 410
 411   mc_accounts_list_free (mc_accounts);
 412 }
 413
 414 static void
 415 disconnect_monitor_signals (McAccountMonitor *monitor,
 416                             GObject *obj)
 417 {
 418   g_signal_handlers_disconnect_by_func (monitor,
 419                                         account_created_cb, obj);
 420   g_signal_handlers_disconnect_by_func (monitor,
 421                                         account_deleted_cb, obj);
 422   g_signal_handlers_disconnect_by_func (monitor,
 423                                         account_disabled_cb, obj);
 424   g_signal_handlers_disconnect_by_func (monitor,
 425                                         account_enabled_cb, obj);
 426   g_signal_handlers_disconnect_by_func (monitor,
 427                                         account_changed_cb, obj);
 428 }
 429
 430 static void
 431 do_finalize (GObject *obj)
 432 {
 433   EmpathyAccountManager *manager = EMPATHY_ACCOUNT_MANAGER (obj);
 434   EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
 435
 436   g_hash_table_unref (priv->accounts);
 437
 438   G_OBJECT_CLASS (empathy_account_manager_parent_class)->finalize (obj);
 439 }
 440
 441 static void
 442 do_dispose (GObject *obj)
 443 {
 444   EmpathyAccountManager *manager = EMPATHY_ACCOUNT_MANAGER (obj);
 445   EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
 446
 447   if (priv->dispose_run)
 448     return;
 449
 450   priv->dispose_run = TRUE;
 451
 452   dbus_g_proxy_disconnect_signal (DBUS_G_PROXY (priv->mc),
 453                                   "AccountStatusChanged",
 454                                   G_CALLBACK (account_status_changed_cb),
 455                                   obj);
 456
 457   disconnect_monitor_signals (priv->monitor, obj);
 458
 459   if (priv->monitor)
 460     {
 461       g_object_unref (priv->monitor);
 462       priv->monitor = NULL;
 463     }
 464
 465   if (priv->mc)
 466     g_object_unref (priv->mc);
 467
 468   g_hash_table_remove_all (priv->accounts);
 469
 470   G_OBJECT_CLASS (empathy_account_manager_parent_class)->dispose (obj);
 471 }
 472
 473 static GObject*
 474 do_constructor (GType type,
 475                 guint n_construct_params,
 476                 GObjectConstructParam *construct_params)
 477 {
 478   GObject *retval;
 479
 480   if (!manager_singleton)
 481     {
 482       retval = G_OBJECT_CLASS (empathy_account_manager_parent_class)->constructor (type,
 483                                                                                    n_construct_params,
 484                                                                                    construct_params);
 485       g_object_add_weak_pointer (retval, (gpointer *) &retval);
 486       manager_singleton = EMPATHY_ACCOUNT_MANAGER (retval);
 487     }
 488   else
 489     {
 490       retval = g_object_ref (manager_singleton);
 491     }
 492
 493   return retval;
 494 }
 495
 496 static void
 497 empathy_account_manager_class_init (EmpathyAccountManagerClass *klass)
 498 {
 499   GObjectClass *oclass = G_OBJECT_CLASS (klass);
 500
 501   oclass->finalize = do_finalize;
 502   oclass->dispose = do_dispose;
 503   oclass->constructor = do_constructor;
 504
 505   signals[ACCOUNT_CREATED] =
 506     g_signal_new ("account-created",
 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, MC_TYPE_ACCOUNT);
 514
 515   signals[ACCOUNT_DELETED] =
 516     g_signal_new ("account-deleted",
 517                   G_TYPE_FROM_CLASS (klass),
 518                   G_SIGNAL_RUN_LAST,
 519                   0,
 520                   NULL, NULL,
 521                   g_cclosure_marshal_VOID__OBJECT,
 522                   G_TYPE_NONE,
 523                   1, MC_TYPE_ACCOUNT);
 524
 525   signals[ACCOUNT_ENABLED] =
 526     g_signal_new ("account-enabled",
 527                   G_TYPE_FROM_CLASS (klass),
 528                   G_SIGNAL_RUN_LAST,
 529                   0,
 530                   NULL, NULL,
 531                   g_cclosure_marshal_VOID__OBJECT,
 532                   G_TYPE_NONE,
 533                   1, MC_TYPE_ACCOUNT);
 534
 535   signals[ACCOUNT_DISABLED] =
 536     g_signal_new ("account-disabled",
 537                   G_TYPE_FROM_CLASS (klass),
 538                   G_SIGNAL_RUN_LAST,
 539                   0,
 540                   NULL, NULL,
 541                   g_cclosure_marshal_VOID__OBJECT,
 542                   G_TYPE_NONE,
 543                   1, MC_TYPE_ACCOUNT);
 544
 545   signals[ACCOUNT_CHANGED] =
 546     g_signal_new ("account-changed",
 547                   G_TYPE_FROM_CLASS (klass),
 548                   G_SIGNAL_RUN_LAST,
 549                   0,
 550                   NULL, NULL,
 551                   g_cclosure_marshal_VOID__OBJECT,
 552                   G_TYPE_NONE,
 553                   1, MC_TYPE_ACCOUNT);
 554
 555   signals[ACCOUNT_CONNECTION_CHANGED] =
 556     g_signal_new ("account-connection-changed",
 557                   G_TYPE_FROM_CLASS (klass),
 558                   G_SIGNAL_RUN_LAST,
 559                   0,
 560                   NULL, NULL,
 561                   _empathy_marshal_VOID__OBJECT_INT_UINT_UINT,
 562                   G_TYPE_NONE,
 563                   4, MC_TYPE_ACCOUNT,
 564                   G_TYPE_INT,   /* reason */
 565                   G_TYPE_UINT,  /* actual connection */
 566                   G_TYPE_UINT); /* previous connection */
 567
 568   signals[ACCOUNT_PRESENCE_CHANGED] =
 569     g_signal_new ("account-presence-changed",
 570                   G_TYPE_FROM_CLASS (klass),
 571                   G_SIGNAL_RUN_LAST,
 572                   0,
 573                   NULL, NULL,
 574                   _empathy_marshal_VOID__OBJECT_INT_INT,
 575                   G_TYPE_NONE,
 576                   3, MC_TYPE_ACCOUNT,
 577                   G_TYPE_INT,  /* actual presence */
 578                   G_TYPE_INT); /* previous presence */
 579
 580   g_type_class_add_private (oclass, sizeof (EmpathyAccountManagerPriv));
 581 }
 582
 583 /* public methods */
 584
 585 EmpathyAccountManager *
 586 empathy_account_manager_dup_singleton (void)
 587 {
 588   return g_object_new (EMPATHY_TYPE_ACCOUNT_MANAGER, NULL);
 589 }
 590
 591 int
 592 empathy_account_manager_get_connected_accounts (EmpathyAccountManager *manager)
 593 {
 594   EmpathyAccountManagerPriv *priv;
 595
 596   g_assert (EMPATHY_IS_ACCOUNT_MANAGER (manager));
 597
 598   priv = GET_PRIV (manager);
 599
 600   return priv->connected;
 601 }
 602
 603 int
 604 empathy_account_manager_get_connecting_accounts (EmpathyAccountManager *manager)
 605 {
 606   EmpathyAccountManagerPriv *priv;
 607
 608   g_assert (EMPATHY_IS_ACCOUNT_MANAGER (manager));
 609
 610   priv = GET_PRIV (manager);
 611
 612   return priv->connecting;
 613 }
 614
 615 gboolean
 616 empathy_account_manager_is_account_just_connected (EmpathyAccountManager *manager,
 617                                                    McAccount *account)
 618 {
 619   EmpathyAccountManagerPriv *priv;
 620   AccountData *data;
 621
 622   g_assert (EMPATHY_IS_ACCOUNT_MANAGER (manager));
 623
 624   priv = GET_PRIV (manager);
 625   data = g_hash_table_lookup (priv->accounts, account);
 626
 627   g_assert (data);
 628
 629   return (data->source_id > 0);
 630 }
 631