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