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
 372   priv = G_TYPE_INSTANCE_GET_PRIVATE (manager,
 373                                       EMPATHY_TYPE_ACCOUNT_MANAGER, EmpathyAccountManagerPriv);
 374   manager->priv = priv;
 375   priv->monitor = mc_account_monitor_new ();
 376   priv->mc = empathy_mission_control_dup_singleton ();
 377   priv->connected = priv->connecting = 0;
 378   priv->dispose_run = FALSE;
 379
 380   priv->accounts = g_hash_table_new_full (empathy_account_hash,
 381                                           empathy_account_equal,
 382                                           g_object_unref,
 383                                           (GDestroyNotify) account_data_free);
 384
 385   mc_accounts = mc_accounts_list ();
 386
 387   for (l = mc_accounts; l; l = l->next)
 388     account_created_cb (priv->monitor, (char *) mc_account_get_unique_name (l->data), manager);
 389
 390   g_signal_connect (priv->monitor, "account-created",
 391                     G_CALLBACK (account_created_cb), manager);
 392   g_signal_connect (priv->monitor, "account-deleted",
 393                     G_CALLBACK (account_deleted_cb), manager);
 394   g_signal_connect (priv->monitor, "account-disabled",
 395                     G_CALLBACK (account_disabled_cb), manager);
 396   g_signal_connect (priv->monitor, "account-enabled",
 397                     G_CALLBACK (account_enabled_cb), manager);
 398   g_signal_connect (priv->monitor, "account-changed",
 399                     G_CALLBACK (account_changed_cb), manager);
 400
 401   dbus_g_proxy_connect_signal (DBUS_G_PROXY (priv->mc), "AccountStatusChanged",
 402                                G_CALLBACK (account_status_changed_cb),
 403                                manager, NULL);
 404
 405   mc_accounts_list_free (mc_accounts);
 406 }
 407
 408 static void
 409 do_finalize (GObject *obj)
 410 {
 411   EmpathyAccountManager *manager = EMPATHY_ACCOUNT_MANAGER (obj);
 412   EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
 413
 414   g_hash_table_unref (priv->accounts);
 415
 416   G_OBJECT_CLASS (empathy_account_manager_parent_class)->finalize (obj);
 417 }
 418
 419 static void
 420 do_dispose (GObject *obj)
 421 {
 422   EmpathyAccountManager *manager = EMPATHY_ACCOUNT_MANAGER (obj);
 423   EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
 424
 425   if (priv->dispose_run)
 426     return;
 427
 428   priv->dispose_run = TRUE;
 429
 430   dbus_g_proxy_disconnect_signal (DBUS_G_PROXY (priv->mc),
 431                                   "AccountStatusChanged",
 432                                   G_CALLBACK (account_status_changed_cb),
 433                                   obj);
 434
 435   if (priv->monitor)
 436     {
 437       g_signal_handlers_disconnect_by_func (priv->monitor,
 438                                             account_created_cb, obj);
 439       g_signal_handlers_disconnect_by_func (priv->monitor,
 440                                             account_deleted_cb, obj);
 441       g_signal_handlers_disconnect_by_func (priv->monitor,
 442                                             account_disabled_cb, obj);
 443       g_signal_handlers_disconnect_by_func (priv->monitor,
 444                                             account_enabled_cb, obj);
 445       g_signal_handlers_disconnect_by_func (priv->monitor,
 446                                             account_changed_cb, obj);
 447       g_object_unref (priv->monitor);
 448       priv->monitor = NULL;
 449     }
 450
 451   if (priv->mc)
 452     g_object_unref (priv->mc);
 453
 454   g_hash_table_remove_all (priv->accounts);
 455
 456   G_OBJECT_CLASS (empathy_account_manager_parent_class)->dispose (obj);
 457 }
 458
 459 static GObject*
 460 do_constructor (GType type,
 461                 guint n_construct_params,
 462                 GObjectConstructParam *construct_params)
 463 {
 464   GObject *retval;
 465
 466   if (!manager_singleton)
 467     {
 468       retval = G_OBJECT_CLASS (empathy_account_manager_parent_class)->constructor (type,
 469                                                                                    n_construct_params,
 470                                                                                    construct_params);
 471       manager_singleton = EMPATHY_ACCOUNT_MANAGER (retval);
 472       g_object_add_weak_pointer (retval, (gpointer) &manager_singleton);
 473     }
 474   else
 475     {
 476       retval = g_object_ref (manager_singleton);
 477     }
 478
 479   return retval;
 480 }
 481
 482 static void
 483 empathy_account_manager_class_init (EmpathyAccountManagerClass *klass)
 484 {
 485   GObjectClass *oclass = G_OBJECT_CLASS (klass);
 486
 487   oclass->finalize = do_finalize;
 488   oclass->dispose = do_dispose;
 489   oclass->constructor = do_constructor;
 490
 491   signals[ACCOUNT_CREATED] =
 492     g_signal_new ("account-created",
 493                   G_TYPE_FROM_CLASS (klass),
 494                   G_SIGNAL_RUN_LAST,
 495                   0,
 496                   NULL, NULL,
 497                   g_cclosure_marshal_VOID__OBJECT,
 498                   G_TYPE_NONE,
 499                   1, MC_TYPE_ACCOUNT);
 500
 501   signals[ACCOUNT_DELETED] =
 502     g_signal_new ("account-deleted",
 503                   G_TYPE_FROM_CLASS (klass),
 504                   G_SIGNAL_RUN_LAST,
 505                   0,
 506                   NULL, NULL,
 507                   g_cclosure_marshal_VOID__OBJECT,
 508                   G_TYPE_NONE,
 509                   1, MC_TYPE_ACCOUNT);
 510
 511   signals[ACCOUNT_ENABLED] =
 512     g_signal_new ("account-enabled",
 513                   G_TYPE_FROM_CLASS (klass),
 514                   G_SIGNAL_RUN_LAST,
 515                   0,
 516                   NULL, NULL,
 517                   g_cclosure_marshal_VOID__OBJECT,
 518                   G_TYPE_NONE,
 519                   1, MC_TYPE_ACCOUNT);
 520
 521   signals[ACCOUNT_DISABLED] =
 522     g_signal_new ("account-disabled",
 523                   G_TYPE_FROM_CLASS (klass),
 524                   G_SIGNAL_RUN_LAST,
 525                   0,
 526                   NULL, NULL,
 527                   g_cclosure_marshal_VOID__OBJECT,
 528                   G_TYPE_NONE,
 529                   1, MC_TYPE_ACCOUNT);
 530
 531   signals[ACCOUNT_CHANGED] =
 532     g_signal_new ("account-changed",
 533                   G_TYPE_FROM_CLASS (klass),
 534                   G_SIGNAL_RUN_LAST,
 535                   0,
 536                   NULL, NULL,
 537                   g_cclosure_marshal_VOID__OBJECT,
 538                   G_TYPE_NONE,
 539                   1, MC_TYPE_ACCOUNT);
 540
 541   signals[ACCOUNT_CONNECTION_CHANGED] =
 542     g_signal_new ("account-connection-changed",
 543                   G_TYPE_FROM_CLASS (klass),
 544                   G_SIGNAL_RUN_LAST,
 545                   0,
 546                   NULL, NULL,
 547                   _empathy_marshal_VOID__OBJECT_INT_UINT_UINT,
 548                   G_TYPE_NONE,
 549                   4, MC_TYPE_ACCOUNT,
 550                   G_TYPE_INT,   /* reason */
 551                   G_TYPE_UINT,  /* actual connection */
 552                   G_TYPE_UINT); /* previous connection */
 553
 554   signals[ACCOUNT_PRESENCE_CHANGED] =
 555     g_signal_new ("account-presence-changed",
 556                   G_TYPE_FROM_CLASS (klass),
 557                   G_SIGNAL_RUN_LAST,
 558                   0,
 559                   NULL, NULL,
 560                   _empathy_marshal_VOID__OBJECT_INT_INT,
 561                   G_TYPE_NONE,
 562                   3, MC_TYPE_ACCOUNT,
 563                   G_TYPE_INT,  /* actual presence */
 564                   G_TYPE_INT); /* previous presence */
 565
 566   g_type_class_add_private (oclass, sizeof (EmpathyAccountManagerPriv));
 567 }
 568
 569 /* public methods */
 570
 571 EmpathyAccountManager *
 572 empathy_account_manager_dup_singleton (void)
 573 {
 574   return g_object_new (EMPATHY_TYPE_ACCOUNT_MANAGER, NULL);
 575 }
 576
 577 int
 578 empathy_account_manager_get_connected_accounts (EmpathyAccountManager *manager)
 579 {
 580   EmpathyAccountManagerPriv *priv;
 581
 582   g_return_val_if_fail (EMPATHY_IS_ACCOUNT_MANAGER (manager), 0);
 583
 584   priv = GET_PRIV (manager);
 585
 586   return priv->connected;
 587 }
 588
 589 int
 590 empathy_account_manager_get_connecting_accounts (EmpathyAccountManager *manager)
 591 {
 592   EmpathyAccountManagerPriv *priv;
 593
 594   g_return_val_if_fail (EMPATHY_IS_ACCOUNT_MANAGER (manager), 0);
 595
 596   priv = GET_PRIV (manager);
 597
 598   return priv->connecting;
 599 }
 600
 601 gboolean
 602 empathy_account_manager_is_account_just_connected (EmpathyAccountManager *manager,
 603                                                    McAccount *account)
 604 {
 605   EmpathyAccountManagerPriv *priv;
 606   AccountData *data;
 607
 608   g_return_val_if_fail (EMPATHY_IS_ACCOUNT_MANAGER (manager), FALSE);
 609
 610   priv = GET_PRIV (manager);
 611   data = g_hash_table_lookup (priv->accounts, account);
 612
 613   g_assert (data);
 614
 615   return (data->source_id > 0);
 616 }
 617
 618 /**
 619  * empathy_account_manager_get_count:
 620  * @manager: a #EmpathyAccountManager
 621  *
 622  * Get the number of accounts.
 623  *
 624  * Returns: the number of accounts.
 625  **/
 626 int
 627 empathy_account_manager_get_count (EmpathyAccountManager *manager)
 628 {
 629   EmpathyAccountManagerPriv *priv;
 630
 631   g_return_val_if_fail (EMPATHY_IS_ACCOUNT_MANAGER (manager), 0);
 632
 633   priv = GET_PRIV (manager);
 634
 635   return g_hash_table_size (priv->accounts);
 636 }