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  *          Sjoerd Simons <sjoerd.simons@collabora.co.uk>
  20  */
  21
  22 #include "config.h"
  23
  24 #include <telepathy-glib/util.h>
  25 #include <telepathy-glib/account-manager.h>
  26 #include <telepathy-glib/enums.h>
  27 #include <telepathy-glib/defs.h>
  28 #include <telepathy-glib/dbus.h>
  29 #include <telepathy-glib/interfaces.h>
  30
  31 #include "empathy-account-manager.h"
  32 #include "empathy-marshal.h"
  33 #include "empathy-utils.h"
  34
  35 #define DEBUG_FLAG EMPATHY_DEBUG_ACCOUNT
  36 #include <libempathy/empathy-debug.h>
  37
  38 #define GET_PRIV(obj) EMPATHY_GET_PRIV (obj, EmpathyAccountManager)
  39
  40 #define MC5_BUS_NAME "org.freedesktop.Telepathy.MissionControl5"
  41
  42 typedef struct {
  43   /* (owned) unique name -> (reffed) EmpathyAccount */
  44   GHashTable       *accounts;
  45   int               connected;
  46   int               connecting;
  47   gboolean          dispose_run;
  48   gboolean          ready;
  49   TpAccountManager *tp_manager;
  50   TpDBusDaemon *dbus;
  51
  52   /* global presence */
  53   EmpathyAccount *global_account;
  54
  55   TpConnectionPresenceType global_presence;
  56   gchar *global_status;
  57   gchar *global_status_message;
  58
  59   /* desired global presence, could be different
  60    * from the actual global one.
  61    */
  62   TpConnectionPresenceType desired_presence;
  63   gchar *desired_status;
  64   gchar *desired_status_message;
  65
  66   GSimpleAsyncResult *create_result;
  67 } EmpathyAccountManagerPriv;
  68
  69 enum {
  70   ACCOUNT_CREATED,
  71   ACCOUNT_DELETED,
  72   ACCOUNT_ENABLED,
  73   ACCOUNT_DISABLED,
  74   ACCOUNT_CHANGED,
  75   ACCOUNT_CONNECTION_CHANGED,
  76   GLOBAL_PRESENCE_CHANGED,
  77   NEW_CONNECTION,
  78   LAST_SIGNAL
  79 };
  80
  81 enum {
  82   PROP_READY = 1,
  83 };
  84
  85 static guint signals[LAST_SIGNAL];
  86 static EmpathyAccountManager *manager_singleton = NULL;
  87
  88 G_DEFINE_TYPE (EmpathyAccountManager, empathy_account_manager, G_TYPE_OBJECT);
  89
  90 static void
  91 emp_account_connection_cb (EmpathyAccount *account,
  92   GParamSpec *spec,
  93   gpointer manager)
  94 {
  95   TpConnection *connection = empathy_account_get_connection (account);
  96
  97   DEBUG ("Signalling connection %p of account %s",
  98       connection, empathy_account_get_unique_name (account));
  99
 100   if (connection != NULL)
 101     g_signal_emit (manager, signals[NEW_CONNECTION], 0, connection);
 102 }
 103
 104 static void
 105 emp_account_enabled_cb (EmpathyAccount *account,
 106   GParamSpec *spec,
 107   gpointer manager)
 108 {
 109   EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
 110
 111   if (empathy_account_is_enabled (account))
 112     {
 113       g_signal_emit (manager, signals[ACCOUNT_ENABLED], 0, account);
 114
 115       /* set the desired global presence on the account */
 116       empathy_account_request_presence (account, priv->desired_presence,
 117           priv->desired_status, priv->desired_status_message);
 118     }
 119   else
 120     g_signal_emit (manager, signals[ACCOUNT_DISABLED], 0, account);
 121 }
 122
 123 static void
 124 emp_account_status_changed_cb (EmpathyAccount *account,
 125   TpConnectionStatus old,
 126   TpConnectionStatus new,
 127   TpConnectionStatusReason reason,
 128   gpointer user_data)
 129 {
 130   EmpathyAccountManager *manager = EMPATHY_ACCOUNT_MANAGER (user_data);
 131   EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
 132
 133   switch (old)
 134     {
 135       case TP_CONNECTION_STATUS_CONNECTING:
 136         priv->connecting--;
 137         break;
 138       case TP_CONNECTION_STATUS_CONNECTED:
 139         priv->connected--;
 140         break;
 141       default:
 142         break;
 143     }
 144
 145   switch (new)
 146     {
 147       case TP_CONNECTION_STATUS_CONNECTING:
 148         priv->connecting++;
 149         break;
 150       case TP_CONNECTION_STATUS_CONNECTED:
 151         priv->connected++;
 152         break;
 153       default:
 154         break;
 155     }
 156
 157   g_signal_emit (manager, signals[ACCOUNT_CONNECTION_CHANGED], 0,
 158     account, reason, new, old);
 159 }
 160
 161 static void
 162 emp_account_manager_update_global_presence (EmpathyAccountManager *manager)
 163 {
 164   EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
 165   TpConnectionPresenceType presence = TP_CONNECTION_PRESENCE_TYPE_OFFLINE;
 166   EmpathyAccount *account = NULL;
 167   GHashTableIter iter;
 168   gpointer value;
 169
 170   g_hash_table_iter_init (&iter, priv->accounts);
 171   while (g_hash_table_iter_next (&iter, NULL, &value))
 172     {
 173       EmpathyAccount *a = EMPATHY_ACCOUNT (value);
 174       TpConnectionPresenceType p;
 175
 176       g_object_get (a, "presence", &p, NULL);
 177
 178       if (tp_connection_presence_type_cmp_availability (p, presence) > 0)
 179         {
 180           account = a;
 181           presence = p;
 182         }
 183     }
 184
 185   priv->global_account = account;
 186   g_free (priv->global_status);
 187   g_free (priv->global_status_message);
 188
 189   if (account == NULL)
 190     {
 191       priv->global_status = NULL;
 192       priv->global_status_message = NULL;
 193       return;
 194     }
 195
 196   g_object_get (account,
 197     "presence", &priv->global_presence,
 198     "status", &priv->global_status,
 199     "status-message", &priv->global_status_message,
 200     NULL);
 201 }
 202
 203 static void
 204 emp_account_presence_changed_cb (EmpathyAccount *account,
 205   TpConnectionPresenceType presence,
 206   const gchar *status,
 207   const gchar *status_message,
 208   gpointer user_data)
 209 {
 210   EmpathyAccountManager *manager = EMPATHY_ACCOUNT_MANAGER (user_data);
 211   EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
 212
 213   if (tp_connection_presence_type_cmp_availability (presence,
 214       priv->global_presence) > 0)
 215     {
 216       priv->global_account = account;
 217
 218       priv->global_presence = presence;
 219
 220       g_free (priv->global_status);
 221       priv->global_status = g_strdup (status);
 222
 223       g_free (priv->global_status_message);
 224       priv->global_status_message = g_strdup (status_message);
 225
 226       goto signal;
 227     }
 228   else if (priv->global_account == account)
 229     {
 230       emp_account_manager_update_global_presence (manager);
 231       goto signal;
 232     }
 233
 234   return;
 235 signal:
 236     g_signal_emit (manager, signals[GLOBAL_PRESENCE_CHANGED], 0,
 237       priv->global_presence, priv->global_status, priv->global_status_message);
 238 }
 239
 240 static void
 241 emp_account_removed_cb (EmpathyAccount *account, gpointer user_data)
 242 {
 243   EmpathyAccountManager *manager = EMPATHY_ACCOUNT_MANAGER (user_data);
 244   EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
 245
 246   g_object_ref (account);
 247   g_hash_table_remove (priv->accounts,
 248     empathy_account_get_unique_name (account));
 249
 250   g_signal_emit (manager, signals[ACCOUNT_DELETED], 0, account);
 251   g_object_unref (account);
 252 }
 253
 254 static void
 255 empathy_account_manager_check_ready (EmpathyAccountManager *manager)
 256 {
 257   EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
 258   GHashTableIter iter;
 259   gpointer value;
 260
 261   if (priv->ready)
 262     return;
 263
 264   g_hash_table_iter_init (&iter, priv->accounts);
 265   while (g_hash_table_iter_next (&iter, NULL, &value))
 266     {
 267       EmpathyAccount *account = EMPATHY_ACCOUNT (value);
 268       gboolean ready;
 269
 270       g_object_get (account, "ready", &ready, NULL);
 271
 272       if (!ready)
 273         return;
 274     }
 275
 276   priv->ready = TRUE;
 277   g_object_notify (G_OBJECT (manager), "ready");
 278 }
 279
 280 static void
 281 account_manager_account_ready_cb (GObject *obj,
 282     GParamSpec *spec,
 283     gpointer user_data)
 284 {
 285   EmpathyAccountManager *manager = EMPATHY_ACCOUNT_MANAGER (user_data);
 286   EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
 287   EmpathyAccount *account = EMPATHY_ACCOUNT (obj);
 288   gboolean ready;
 289
 290   g_object_get (account, "ready", &ready, NULL);
 291
 292   if (!ready)
 293     return;
 294
 295   if (priv->create_result)
 296     {
 297       g_simple_async_result_set_op_res_gpointer (
 298           G_SIMPLE_ASYNC_RESULT (priv->create_result), account, NULL);
 299
 300       g_simple_async_result_complete (priv->create_result);
 301       g_object_unref (priv->create_result);
 302       priv->create_result = NULL;
 303     }
 304
 305   g_signal_emit (manager, signals[ACCOUNT_CREATED], 0, account);
 306
 307   g_signal_connect (account, "notify::connection",
 308     G_CALLBACK (emp_account_connection_cb), manager);
 309
 310   g_signal_connect (account, "notify::enabled",
 311     G_CALLBACK (emp_account_enabled_cb), manager);
 312
 313   g_signal_connect (account, "status-changed",
 314     G_CALLBACK (emp_account_status_changed_cb), manager);
 315
 316   g_signal_connect (account, "presence-changed",
 317     G_CALLBACK (emp_account_presence_changed_cb), manager);
 318
 319   g_signal_connect (account, "removed",
 320     G_CALLBACK (emp_account_removed_cb), manager);
 321
 322   empathy_account_manager_check_ready (manager);
 323 }
 324
 325 static void
 326 account_manager_add_account (EmpathyAccountManager *manager,
 327   const gchar *path)
 328 {
 329   EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
 330   EmpathyAccount *account;
 331
 332   account = g_hash_table_lookup (priv->accounts, path);
 333   if (account != NULL)
 334     return;
 335
 336   account = empathy_account_new (priv->dbus, path);
 337   g_hash_table_insert (priv->accounts, g_strdup (path), account);
 338
 339   g_signal_connect (account, "notify::ready",
 340     G_CALLBACK (account_manager_account_ready_cb), manager);
 341 }
 342
 343 static void
 344 account_manager_got_all_cb (TpProxy *proxy,
 345     GHashTable *properties,
 346     const GError *error,
 347     gpointer user_data,
 348     GObject *weak_object)
 349 {
 350   EmpathyAccountManager *manager = EMPATHY_ACCOUNT_MANAGER (weak_object);
 351   GPtrArray *accounts;
 352   int i;
 353
 354   if (error != NULL)
 355     {
 356       DEBUG ("Failed to get account manager properties: %s", error->message);
 357       return;
 358     }
 359
 360   accounts = tp_asv_get_boxed (properties, "ValidAccounts",
 361     EMPATHY_ARRAY_TYPE_OBJECT);
 362
 363   for (i = 0; i < accounts->len; i++)
 364     {
 365       gchar *name = g_ptr_array_index (accounts, i);
 366
 367       account_manager_add_account (manager, name);
 368     }
 369
 370   empathy_account_manager_check_ready (manager);
 371 }
 372
 373 static void
 374 account_validity_changed_cb (TpAccountManager *proxy,
 375     const gchar *path,
 376     gboolean valid,
 377     gpointer user_data,
 378     GObject *weak_object)
 379 {
 380   EmpathyAccountManager *manager = EMPATHY_ACCOUNT_MANAGER (weak_object);
 381
 382   if (!valid)
 383     return;
 384
 385   account_manager_add_account (manager, path);
 386 }
 387
 388 static void
 389 account_manager_name_owner_cb (TpDBusDaemon *proxy,
 390     const gchar *name,
 391     const gchar *new_owner,
 392     gpointer user_data)
 393 {
 394   EmpathyAccountManager *manager = EMPATHY_ACCOUNT_MANAGER (user_data);
 395   EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
 396
 397   tp_dbus_daemon_cancel_name_owner_watch (proxy, name,
 398     account_manager_name_owner_cb, user_data);
 399
 400   priv->tp_manager = tp_account_manager_new (priv->dbus);
 401
 402   tp_cli_account_manager_connect_to_account_validity_changed (
 403       priv->tp_manager,
 404       account_validity_changed_cb,
 405       NULL,
 406       NULL,
 407       G_OBJECT (manager),
 408       NULL);
 409
 410   tp_cli_dbus_properties_call_get_all (priv->tp_manager, -1,
 411     TP_IFACE_ACCOUNT_MANAGER,
 412     account_manager_got_all_cb,
 413     NULL,
 414     NULL,
 415     G_OBJECT (manager));
 416 }
 417
 418 static void
 419 empathy_account_manager_init (EmpathyAccountManager *manager)
 420 {
 421   EmpathyAccountManagerPriv *priv;
 422   TpProxy *mc5_proxy;
 423
 424   priv = G_TYPE_INSTANCE_GET_PRIVATE (manager,
 425       EMPATHY_TYPE_ACCOUNT_MANAGER, EmpathyAccountManagerPriv);
 426
 427   manager->priv = priv;
 428   priv->connected = priv->connecting = 0;
 429   priv->global_presence = TP_CONNECTION_PRESENCE_TYPE_UNSET;
 430
 431   priv->accounts = g_hash_table_new_full (g_str_hash, g_str_equal,
 432       g_free, (GDestroyNotify) g_object_unref);
 433
 434   priv->dbus = tp_dbus_daemon_dup (NULL);
 435
 436   tp_dbus_daemon_watch_name_owner (priv->dbus,
 437       TP_ACCOUNT_MANAGER_BUS_NAME,
 438       account_manager_name_owner_cb,
 439       manager,
 440       NULL);
 441
 442   /* trigger MC5 starting */
 443   mc5_proxy = g_object_new (TP_TYPE_PROXY,
 444     "dbus-daemon", priv->dbus,
 445     "dbus-connection", tp_proxy_get_dbus_connection (TP_PROXY (priv->dbus)),
 446     "bus-name", MC5_BUS_NAME,
 447     "object-path", "/",
 448     NULL);
 449
 450   tp_cli_dbus_peer_call_ping (mc5_proxy, -1, NULL, NULL, NULL, NULL);
 451
 452   g_object_unref (mc5_proxy);
 453 }
 454
 455 static void
 456 do_finalize (GObject *obj)
 457 {
 458   EmpathyAccountManager *manager = EMPATHY_ACCOUNT_MANAGER (obj);
 459   EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
 460
 461   g_hash_table_destroy (priv->accounts);
 462
 463   g_free (priv->global_status);
 464   g_free (priv->global_status_message);
 465
 466   g_free (priv->desired_status);
 467   g_free (priv->desired_status_message);
 468
 469   G_OBJECT_CLASS (empathy_account_manager_parent_class)->finalize (obj);
 470 }
 471
 472 static void
 473 do_dispose (GObject *obj)
 474 {
 475   EmpathyAccountManager *manager = EMPATHY_ACCOUNT_MANAGER (obj);
 476   EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
 477
 478   if (priv->dispose_run)
 479     return;
 480
 481   priv->dispose_run = TRUE;
 482
 483   if (priv->create_result != NULL)
 484     {
 485       g_simple_async_result_set_error (priv->create_result, G_IO_ERROR,
 486           G_IO_ERROR_CANCELLED, "The account manager was disposed while "
 487           "creating the account");
 488       g_simple_async_result_complete (priv->create_result);
 489       g_object_unref (priv->create_result);
 490       priv->create_result = NULL;
 491     }
 492
 493   tp_dbus_daemon_cancel_name_owner_watch (priv->dbus,
 494       TP_ACCOUNT_MANAGER_BUS_NAME, account_manager_name_owner_cb, manager);
 495
 496   if (priv->dbus != NULL)
 497     {
 498       g_object_unref (priv->dbus);
 499       priv->dbus = NULL;
 500     }
 501
 502   G_OBJECT_CLASS (empathy_account_manager_parent_class)->dispose (obj);
 503 }
 504
 505 static GObject *
 506 do_constructor (GType type,
 507                 guint n_construct_params,
 508                 GObjectConstructParam *construct_params)
 509 {
 510   GObject *retval;
 511
 512   if (!manager_singleton)
 513     {
 514       retval = G_OBJECT_CLASS (empathy_account_manager_parent_class)->constructor (type,
 515                                                                                    n_construct_params,
 516                                                                                    construct_params);
 517       manager_singleton = EMPATHY_ACCOUNT_MANAGER (retval);
 518       g_object_add_weak_pointer (retval, (gpointer) &manager_singleton);
 519     }
 520   else
 521     {
 522       retval = g_object_ref (manager_singleton);
 523     }
 524
 525   return retval;
 526 }
 527
 528 static void
 529 do_get_property (GObject *object,
 530     guint prop_id,
 531     GValue *value,
 532     GParamSpec *pspec)
 533 {
 534   EmpathyAccountManager *manager = EMPATHY_ACCOUNT_MANAGER (object);
 535   EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
 536
 537   switch (prop_id)
 538     {
 539       case PROP_READY:
 540         g_value_set_boolean (value, priv->ready);
 541         break;
 542       default:
 543         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 544         break;
 545     }
 546 }
 547
 548 static void
 549 empathy_account_manager_class_init (EmpathyAccountManagerClass *klass)
 550 {
 551   GObjectClass *oclass = G_OBJECT_CLASS (klass);
 552
 553   oclass->finalize = do_finalize;
 554   oclass->dispose = do_dispose;
 555   oclass->constructor = do_constructor;
 556   oclass->get_property = do_get_property;
 557
 558   g_object_class_install_property (oclass, PROP_READY,
 559     g_param_spec_boolean ("ready",
 560       "Ready",
 561       "Whether the initial state dump from the account manager is finished",
 562       FALSE,
 563       G_PARAM_STATIC_STRINGS | G_PARAM_READABLE));
 564
 565   signals[ACCOUNT_CREATED] =
 566     g_signal_new ("account-created",
 567                   G_TYPE_FROM_CLASS (klass),
 568                   G_SIGNAL_RUN_LAST,
 569                   0,
 570                   NULL, NULL,
 571                   g_cclosure_marshal_VOID__OBJECT,
 572                   G_TYPE_NONE,
 573                   1, EMPATHY_TYPE_ACCOUNT);
 574
 575   signals[ACCOUNT_DELETED] =
 576     g_signal_new ("account-deleted",
 577                   G_TYPE_FROM_CLASS (klass),
 578                   G_SIGNAL_RUN_LAST,
 579                   0,
 580                   NULL, NULL,
 581                   g_cclosure_marshal_VOID__OBJECT,
 582                   G_TYPE_NONE,
 583                   1, EMPATHY_TYPE_ACCOUNT);
 584
 585   signals[ACCOUNT_ENABLED] =
 586     g_signal_new ("account-enabled",
 587                   G_TYPE_FROM_CLASS (klass),
 588                   G_SIGNAL_RUN_LAST,
 589                   0,
 590                   NULL, NULL,
 591                   g_cclosure_marshal_VOID__OBJECT,
 592                   G_TYPE_NONE,
 593                   1, EMPATHY_TYPE_ACCOUNT);
 594
 595   signals[ACCOUNT_DISABLED] =
 596     g_signal_new ("account-disabled",
 597                   G_TYPE_FROM_CLASS (klass),
 598                   G_SIGNAL_RUN_LAST,
 599                   0,
 600                   NULL, NULL,
 601                   g_cclosure_marshal_VOID__OBJECT,
 602                   G_TYPE_NONE,
 603                   1, EMPATHY_TYPE_ACCOUNT);
 604
 605   signals[ACCOUNT_CHANGED] =
 606     g_signal_new ("account-changed",
 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, EMPATHY_TYPE_ACCOUNT);
 614
 615   signals[ACCOUNT_CONNECTION_CHANGED] =
 616     g_signal_new ("account-connection-changed",
 617                   G_TYPE_FROM_CLASS (klass),
 618                   G_SIGNAL_RUN_LAST,
 619                   0,
 620                   NULL, NULL,
 621                   _empathy_marshal_VOID__OBJECT_INT_UINT_UINT,
 622                   G_TYPE_NONE,
 623                   4, EMPATHY_TYPE_ACCOUNT,
 624                   G_TYPE_INT,   /* reason */
 625                   G_TYPE_UINT,  /* actual connection */
 626                   G_TYPE_UINT); /* previous connection */
 627
 628   signals[GLOBAL_PRESENCE_CHANGED] =
 629     g_signal_new ("global-presence-changed",
 630                   G_TYPE_FROM_CLASS (klass),
 631                   G_SIGNAL_RUN_LAST,
 632                   0,
 633                   NULL, NULL,
 634                   _empathy_marshal_VOID__UINT_STRING_STRING,
 635                   G_TYPE_NONE,
 636                   3, G_TYPE_UINT, /* Presence type */
 637                   G_TYPE_STRING,  /* status */
 638                   G_TYPE_STRING); /* stauts message*/
 639
 640   signals[NEW_CONNECTION] =
 641     g_signal_new ("new-connection",
 642                   G_TYPE_FROM_CLASS (klass),
 643                   G_SIGNAL_RUN_LAST,
 644                   0,
 645                   NULL, NULL,
 646                   g_cclosure_marshal_VOID__OBJECT,
 647                   G_TYPE_NONE,
 648                   1, TP_TYPE_CONNECTION);
 649
 650   g_type_class_add_private (oclass, sizeof (EmpathyAccountManagerPriv));
 651 }
 652
 653 /* public methods */
 654
 655 EmpathyAccountManager *
 656 empathy_account_manager_dup_singleton (void)
 657 {
 658   return g_object_new (EMPATHY_TYPE_ACCOUNT_MANAGER, NULL);
 659 }
 660
 661 gboolean
 662 empathy_account_manager_is_ready (EmpathyAccountManager *manager)
 663 {
 664   EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
 665
 666   return priv->ready;
 667 }
 668
 669 int
 670 empathy_account_manager_get_connected_accounts (EmpathyAccountManager *manager)
 671 {
 672   EmpathyAccountManagerPriv *priv;
 673
 674   g_return_val_if_fail (EMPATHY_IS_ACCOUNT_MANAGER (manager), 0);
 675
 676   priv = GET_PRIV (manager);
 677
 678   return priv->connected;
 679 }
 680
 681 int
 682 empathy_account_manager_get_connecting_accounts (EmpathyAccountManager *manager)
 683 {
 684   EmpathyAccountManagerPriv *priv;
 685
 686   g_return_val_if_fail (EMPATHY_IS_ACCOUNT_MANAGER (manager), 0);
 687
 688   priv = GET_PRIV (manager);
 689
 690   return priv->connecting;
 691 }
 692
 693 /**
 694  * empathy_account_manager_get_count:
 695  * @manager: a #EmpathyAccountManager
 696  *
 697  * Get the number of accounts.
 698  *
 699  * Returns: the number of accounts.
 700  **/
 701 int
 702 empathy_account_manager_get_count (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 g_hash_table_size (priv->accounts);
 711 }
 712
 713 EmpathyAccount *
 714 empathy_account_manager_get_account (EmpathyAccountManager *manager,
 715                                      TpConnection          *connection)
 716 {
 717   EmpathyAccountManagerPriv *priv;
 718   GHashTableIter iter;
 719   gpointer value;
 720
 721   g_return_val_if_fail (EMPATHY_IS_ACCOUNT_MANAGER (manager), 0);
 722
 723   priv = GET_PRIV (manager);
 724
 725   g_hash_table_iter_init (&iter, priv->accounts);
 726   while (g_hash_table_iter_next (&iter, NULL, &value))
 727     {
 728       EmpathyAccount *account = EMPATHY_ACCOUNT (value);
 729
 730       if (connection == empathy_account_get_connection (account))
 731           return account;
 732     }
 733
 734   return NULL;
 735 }
 736
 737 EmpathyAccount *
 738 empathy_account_manager_lookup (EmpathyAccountManager *manager,
 739     const gchar *unique_name)
 740 {
 741   EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
 742   EmpathyAccount *account;
 743
 744   account = g_hash_table_lookup (priv->accounts, unique_name);
 745
 746   if (account != NULL)
 747     g_object_ref (account);
 748
 749   return account;
 750 }
 751
 752 GList *
 753 empathy_account_manager_dup_accounts (EmpathyAccountManager *manager)
 754 {
 755   EmpathyAccountManagerPriv *priv;
 756   GList *ret;
 757
 758   g_return_val_if_fail (EMPATHY_IS_ACCOUNT_MANAGER (manager), NULL);
 759
 760   priv = GET_PRIV (manager);
 761
 762   ret = g_hash_table_get_values (priv->accounts);
 763   g_list_foreach (ret, (GFunc) g_object_ref, NULL);
 764
 765   return ret;
 766 }
 767
 768 /**
 769  * empathy_account_manager_dup_connections:
 770  * @manager: a #EmpathyAccountManager
 771  *
 772  * Get a #GList of all ready #TpConnection. The list must be freed with
 773  * g_list_free, and its elements must be unreffed.
 774  *
 775  * Returns: the list of connections
 776  **/
 777 GList *
 778 empathy_account_manager_dup_connections (EmpathyAccountManager *manager)
 779 {
 780   EmpathyAccountManagerPriv *priv;
 781   GHashTableIter iter;
 782   gpointer value;
 783   GList *ret = NULL;
 784
 785   g_return_val_if_fail (EMPATHY_IS_ACCOUNT_MANAGER (manager), NULL);
 786
 787   priv = GET_PRIV (manager);
 788
 789   g_hash_table_iter_init (&iter, priv->accounts);
 790   while (g_hash_table_iter_next (&iter, NULL, &value))
 791     {
 792       EmpathyAccount *account = EMPATHY_ACCOUNT (value);
 793       TpConnection *connection;
 794
 795       connection = empathy_account_get_connection (account);
 796       if (connection != NULL)
 797         ret = g_list_prepend (ret, g_object_ref (connection));
 798     }
 799
 800   return ret;
 801 }
 802
 803 void
 804 empathy_account_manager_remove (EmpathyAccountManager *manager,
 805     EmpathyAccount *account)
 806 {
 807   /* FIXME */
 808 }
 809
 810
 811 void
 812 empathy_account_manager_request_global_presence (
 813   EmpathyAccountManager *manager,
 814   TpConnectionPresenceType type,
 815   const gchar *status,
 816   const gchar *message)
 817 {
 818   EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
 819   GHashTableIter iter;
 820   gpointer value;
 821
 822   g_hash_table_iter_init (&iter, priv->accounts);
 823   while (g_hash_table_iter_next (&iter, NULL, &value))
 824     {
 825       EmpathyAccount *account = EMPATHY_ACCOUNT (value);
 826       gboolean ready;
 827
 828       g_object_get (account, "ready", &ready, NULL);
 829
 830       if (ready)
 831         empathy_account_request_presence (account, type, status, message);
 832     }
 833
 834   /* save the requested global presence, to use it in case we create
 835    * new accounts.
 836    */
 837   priv->desired_presence = type;
 838
 839   if (tp_strdiff (priv->desired_status, status))
 840     {
 841       g_free (priv->desired_status);
 842       priv->desired_status = g_strdup (status);
 843     }
 844
 845   if (tp_strdiff (priv->desired_status_message, message))
 846     {
 847       g_free (priv->desired_status_message);
 848       priv->desired_status_message = g_strdup (message);
 849     }
 850 }
 851
 852 TpConnectionPresenceType
 853 empathy_account_manager_get_global_presence (
 854   EmpathyAccountManager *manager,
 855   gchar **status,
 856   gchar **message)
 857 {
 858   EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
 859
 860   if (status != NULL)
 861     *status = g_strdup (priv->global_status);
 862   if (message != NULL)
 863     *message = g_strdup (priv->global_status_message);
 864
 865   return priv->global_presence;
 866 }
 867
 868 static void
 869 empathy_account_manager_created_cb (TpAccountManager *proxy,
 870     const gchar *account_path,
 871     const GError *error,
 872     gpointer user_data,
 873     GObject *weak_object)
 874 {
 875   EmpathyAccountManager *manager = EMPATHY_ACCOUNT_MANAGER (weak_object);
 876   EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
 877
 878   if (error != NULL)
 879     {
 880       g_simple_async_result_set_from_error (priv->create_result,
 881           (GError *) error);
 882       g_simple_async_result_complete (priv->create_result);
 883       g_object_unref (priv->create_result);
 884       priv->create_result = NULL;
 885
 886       return;
 887     }
 888
 889   account_manager_add_account (manager, account_path);
 890 }
 891
 892 void
 893 empathy_account_manager_create_account_async (EmpathyAccountManager *manager,
 894   const gchar *connection_manager,
 895   const gchar *protocol, const gchar *display_name,
 896   GHashTable *parameters, GHashTable *properties,
 897   GAsyncReadyCallback callback, gpointer user_data)
 898 {
 899   EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
 900
 901   priv->create_result = g_simple_async_result_new
 902     (G_OBJECT (manager), callback, user_data,
 903      empathy_account_manager_create_account_finish);
 904
 905   tp_cli_account_manager_call_create_account (priv->tp_manager,
 906       -1,
 907       connection_manager,
 908       protocol,
 909       display_name,
 910       parameters,
 911       properties,
 912       empathy_account_manager_created_cb,
 913       NULL,
 914       NULL,
 915       G_OBJECT (manager));
 916 }
 917
 918 EmpathyAccount *
 919 empathy_account_manager_create_account_finish (
 920   EmpathyAccountManager *manager, GAsyncResult *result, GError **error)
 921 {
 922   EmpathyAccount *retval;
 923
 924   if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result),
 925       error))
 926     return NULL;
 927
 928   g_return_val_if_fail (g_simple_async_result_is_valid (result,
 929     G_OBJECT (manager), empathy_account_manager_create_account_finish), NULL);
 930
 931   retval = EMPATHY_ACCOUNT (g_simple_async_result_get_op_res_gpointer (
 932     G_SIMPLE_ASYNC_RESULT (result)));
 933
 934   return retval;
 935 }
 936