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 do_finalize (GObject *obj)
 416 {
 417   EmpathyAccountManager *manager = EMPATHY_ACCOUNT_MANAGER (obj);
 418   EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
 419
 420   g_hash_table_unref (priv->accounts);
 421
 422   G_OBJECT_CLASS (empathy_account_manager_parent_class)->finalize (obj);
 423 }
 424
 425 static void
 426 do_dispose (GObject *obj)
 427 {
 428   EmpathyAccountManager *manager = EMPATHY_ACCOUNT_MANAGER (obj);
 429   EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
 430
 431   if (priv->dispose_run)
 432     return;
 433
 434   priv->dispose_run = TRUE;
 435
 436   dbus_g_proxy_disconnect_signal (DBUS_G_PROXY (priv->mc),
 437                                   "AccountStatusChanged",
 438                                   G_CALLBACK (account_status_changed_cb),
 439                                   obj);
 440
 441   if (priv->monitor)
 442     {
 443       g_signal_handlers_disconnect_by_func (priv->monitor,
 444                                             account_created_cb, obj);
 445       g_signal_handlers_disconnect_by_func (priv->monitor,
 446                                             account_deleted_cb, obj);
 447       g_signal_handlers_disconnect_by_func (priv->monitor,
 448                                             account_disabled_cb, obj);
 449       g_signal_handlers_disconnect_by_func (priv->monitor,
 450                                             account_enabled_cb, obj);
 451       g_signal_handlers_disconnect_by_func (priv->monitor,
 452                                             account_changed_cb, obj);
 453       g_object_unref (priv->monitor);
 454       priv->monitor = NULL;
 455     }
 456
 457   if (priv->mc)
 458     g_object_unref (priv->mc);
 459
 460   g_hash_table_remove_all (priv->accounts);
 461
 462   G_OBJECT_CLASS (empathy_account_manager_parent_class)->dispose (obj);
 463 }
 464
 465 static GObject*
 466 do_constructor (GType type,
 467                 guint n_construct_params,
 468                 GObjectConstructParam *construct_params)
 469 {
 470   GObject *retval;
 471
 472   if (!manager_singleton)
 473     {
 474       retval = G_OBJECT_CLASS (empathy_account_manager_parent_class)->constructor (type,
 475                                                                                    n_construct_params,
 476                                                                                    construct_params);
 477       manager_singleton = EMPATHY_ACCOUNT_MANAGER (retval);
 478       g_object_add_weak_pointer (retval, (gpointer *) &manager_singleton);
 479     }
 480   else
 481     {
 482       retval = g_object_ref (manager_singleton);
 483     }
 484
 485   return retval;
 486 }
 487
 488 static void
 489 empathy_account_manager_class_init (EmpathyAccountManagerClass *klass)
 490 {
 491   GObjectClass *oclass = G_OBJECT_CLASS (klass);
 492
 493   oclass->finalize = do_finalize;
 494   oclass->dispose = do_dispose;
 495   oclass->constructor = do_constructor;
 496
 497   signals[ACCOUNT_CREATED] =
 498     g_signal_new ("account-created",
 499                   G_TYPE_FROM_CLASS (klass),
 500                   G_SIGNAL_RUN_LAST,
 501                   0,
 502                   NULL, NULL,
 503                   g_cclosure_marshal_VOID__OBJECT,
 504                   G_TYPE_NONE,
 505                   1, MC_TYPE_ACCOUNT);
 506
 507   signals[ACCOUNT_DELETED] =
 508     g_signal_new ("account-deleted",
 509                   G_TYPE_FROM_CLASS (klass),
 510                   G_SIGNAL_RUN_LAST,
 511                   0,
 512                   NULL, NULL,
 513                   g_cclosure_marshal_VOID__OBJECT,
 514                   G_TYPE_NONE,
 515                   1, MC_TYPE_ACCOUNT);
 516
 517   signals[ACCOUNT_ENABLED] =
 518     g_signal_new ("account-enabled",
 519                   G_TYPE_FROM_CLASS (klass),
 520                   G_SIGNAL_RUN_LAST,
 521                   0,
 522                   NULL, NULL,
 523                   g_cclosure_marshal_VOID__OBJECT,
 524                   G_TYPE_NONE,
 525                   1, MC_TYPE_ACCOUNT);
 526
 527   signals[ACCOUNT_DISABLED] =
 528     g_signal_new ("account-disabled",
 529                   G_TYPE_FROM_CLASS (klass),
 530                   G_SIGNAL_RUN_LAST,
 531                   0,
 532                   NULL, NULL,
 533                   g_cclosure_marshal_VOID__OBJECT,
 534                   G_TYPE_NONE,
 535                   1, MC_TYPE_ACCOUNT);
 536
 537   signals[ACCOUNT_CHANGED] =
 538     g_signal_new ("account-changed",
 539                   G_TYPE_FROM_CLASS (klass),
 540                   G_SIGNAL_RUN_LAST,
 541                   0,
 542                   NULL, NULL,
 543                   g_cclosure_marshal_VOID__OBJECT,
 544                   G_TYPE_NONE,
 545                   1, MC_TYPE_ACCOUNT);
 546
 547   signals[ACCOUNT_CONNECTION_CHANGED] =
 548     g_signal_new ("account-connection-changed",
 549                   G_TYPE_FROM_CLASS (klass),
 550                   G_SIGNAL_RUN_LAST,
 551                   0,
 552                   NULL, NULL,
 553                   _empathy_marshal_VOID__OBJECT_INT_UINT_UINT,
 554                   G_TYPE_NONE,
 555                   4, MC_TYPE_ACCOUNT,
 556                   G_TYPE_INT,   /* reason */
 557                   G_TYPE_UINT,  /* actual connection */
 558                   G_TYPE_UINT); /* previous connection */
 559
 560   signals[ACCOUNT_PRESENCE_CHANGED] =
 561     g_signal_new ("account-presence-changed",
 562                   G_TYPE_FROM_CLASS (klass),
 563                   G_SIGNAL_RUN_LAST,
 564                   0,
 565                   NULL, NULL,
 566                   _empathy_marshal_VOID__OBJECT_INT_INT,
 567                   G_TYPE_NONE,
 568                   3, MC_TYPE_ACCOUNT,
 569                   G_TYPE_INT,  /* actual presence */
 570                   G_TYPE_INT); /* previous presence */
 571
 572   g_type_class_add_private (oclass, sizeof (EmpathyAccountManagerPriv));
 573 }
 574
 575 /* public methods */
 576
 577 EmpathyAccountManager *
 578 empathy_account_manager_dup_singleton (void)
 579 {
 580   return g_object_new (EMPATHY_TYPE_ACCOUNT_MANAGER, NULL);
 581 }
 582
 583 int
 584 empathy_account_manager_get_connected_accounts (EmpathyAccountManager *manager)
 585 {
 586   EmpathyAccountManagerPriv *priv;
 587
 588   g_assert (EMPATHY_IS_ACCOUNT_MANAGER (manager));
 589
 590   priv = GET_PRIV (manager);
 591
 592   return priv->connected;
 593 }
 594
 595 int
 596 empathy_account_manager_get_connecting_accounts (EmpathyAccountManager *manager)
 597 {
 598   EmpathyAccountManagerPriv *priv;
 599
 600   g_assert (EMPATHY_IS_ACCOUNT_MANAGER (manager));
 601
 602   priv = GET_PRIV (manager);
 603
 604   return priv->connecting;
 605 }
 606
 607 gboolean
 608 empathy_account_manager_is_account_just_connected (EmpathyAccountManager *manager,
 609                                                    McAccount *account)
 610 {
 611   EmpathyAccountManagerPriv *priv;
 612   AccountData *data;
 613
 614   g_assert (EMPATHY_IS_ACCOUNT_MANAGER (manager));
 615
 616   priv = GET_PRIV (manager);
 617   data = g_hash_table_lookup (priv->accounts, account);
 618
 619   g_assert (data);
 620
 621   return (data->source_id > 0);
 622 }
 623