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/interfaces.h>
  29
  30 #include "empathy-account-manager.h"
  31 #include "empathy-marshal.h"
  32 #include "empathy-utils.h"
  33
  34 #define DEBUG_FLAG EMPATHY_DEBUG_ACCOUNT
  35 #include <libempathy/empathy-debug.h>
  36
  37 #define GET_PRIV(obj) EMPATHY_GET_PRIV (obj, EmpathyAccountManager)
  38
  39 #define MC5_BUS_NAME "org.freedesktop.Telepathy.MissionControl5"
  40
  41 typedef struct {
  42   /* (owned) unique name -> (reffed) EmpathyAccount */
  43   GHashTable       *accounts;
  44   int               connected;
  45   int               connecting;
  46   gboolean          dispose_run;
  47   gboolean          ready;
  48   TpProxySignalConnection *proxy_signal;
  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 empathy_account_manager_check_ready (EmpathyAccountManager *manager)
 225 {
 226   EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
 227   GHashTableIter iter;
 228   gpointer value;
 229
 230   if (priv->ready)
 231     return;
 232
 233   g_hash_table_iter_init (&iter, priv->accounts);
 234   while (g_hash_table_iter_next (&iter, NULL, &value))
 235     {
 236       EmpathyAccount *account = EMPATHY_ACCOUNT (value);
 237       gboolean ready;
 238
 239       g_object_get (account, "ready", &ready, NULL);
 240
 241       if (!ready)
 242         return;
 243     }
 244
 245   priv->ready = TRUE;
 246   g_object_notify (G_OBJECT (manager), "ready");
 247 }
 248
 249 static void
 250 emp_account_ready_cb (GObject *obj, GParamSpec *spec, gpointer user_data)
 251 {
 252   EmpathyAccountManager *manager = EMPATHY_ACCOUNT_MANAGER (user_data);
 253   EmpathyAccount *account = EMPATHY_ACCOUNT (obj);
 254   gboolean ready;
 255
 256   g_object_get (account, "ready", &ready, NULL);
 257
 258   if (!ready)
 259     return;
 260
 261   g_signal_emit (manager, signals[ACCOUNT_CREATED], 0, account);
 262
 263   g_signal_connect (account, "notify::connection",
 264     G_CALLBACK (emp_account_connection_cb), manager);
 265
 266   g_signal_connect (account, "notify::enabled",
 267     G_CALLBACK (emp_account_enabled_cb), manager);
 268
 269   g_signal_connect (account, "status-changed",
 270     G_CALLBACK (emp_account_status_changed_cb), manager);
 271
 272   g_signal_connect (account, "presence-changed",
 273     G_CALLBACK (emp_account_presence_changed_cb), manager);
 274
 275   empathy_account_manager_check_ready (manager);
 276 }
 277
 278 static EmpathyAccount *
 279 account_manager_add_account (EmpathyAccountManager *manager,
 280   const gchar *path)
 281 {
 282   EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
 283   EmpathyAccount *account;
 284
 285   account = empathy_account_new (priv->dbus, path);
 286   g_hash_table_insert (priv->accounts, g_strdup (path), account);
 287
 288   g_signal_connect (account, "notify::ready",
 289     G_CALLBACK (emp_account_ready_cb), manager);
 290
 291   return account;
 292 }
 293
 294 static void
 295 account_manager_got_all_cb (TpProxy *proxy,
 296     GHashTable *properties,
 297     const GError *error,
 298     gpointer user_data,
 299     GObject *weak_object)
 300 {
 301   EmpathyAccountManager *manager = EMPATHY_ACCOUNT_MANAGER (weak_object);
 302   GPtrArray *accounts;
 303   int i;
 304
 305   if (error != NULL)
 306     {
 307       DEBUG ("Failed to get account manager properties: %s", error->message);
 308       return;
 309     }
 310
 311   accounts = tp_asv_get_boxed (properties, "ValidAccounts",
 312     EMPATHY_ARRAY_TYPE_OBJECT);
 313
 314   for (i = 0; i < accounts->len; i++)
 315     {
 316       gchar *name = g_ptr_array_index (accounts, i);
 317
 318       account_manager_add_account (manager, name);
 319     }
 320
 321   empathy_account_manager_check_ready (manager);
 322 }
 323
 324 static void
 325 account_manager_name_owner_changed_cb (TpDBusDaemon *proxy,
 326     const gchar *arg0,
 327     const gchar *arg1,
 328     const gchar *arg2,
 329     gpointer user_data,
 330     GObject *weak_object)
 331 {
 332   EmpathyAccountManager *manager = EMPATHY_ACCOUNT_MANAGER (weak_object);
 333   EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
 334
 335   tp_proxy_signal_connection_disconnect (priv->proxy_signal);
 336   priv->proxy_signal = NULL;
 337
 338   priv->tp_manager = tp_account_manager_new (priv->dbus);
 339   tp_cli_dbus_properties_call_get_all (priv->tp_manager, -1,
 340     TP_IFACE_ACCOUNT_MANAGER,
 341     account_manager_got_all_cb,
 342     NULL,
 343     NULL,
 344     G_OBJECT (manager));
 345 }
 346
 347 static void
 348 empathy_account_manager_init (EmpathyAccountManager *manager)
 349 {
 350   EmpathyAccountManagerPriv *priv;
 351   TpProxy *mc5_proxy;
 352
 353   priv = G_TYPE_INSTANCE_GET_PRIVATE (manager,
 354       EMPATHY_TYPE_ACCOUNT_MANAGER, EmpathyAccountManagerPriv);
 355
 356   manager->priv = priv;
 357   priv->connected = priv->connecting = 0;
 358   priv->global_presence = TP_CONNECTION_PRESENCE_TYPE_UNSET;
 359
 360   priv->accounts = g_hash_table_new_full (g_str_hash, g_str_equal,
 361       g_free, (GDestroyNotify) g_object_unref);
 362
 363   priv->dbus = tp_dbus_daemon_dup (NULL);
 364
 365   priv->proxy_signal = tp_cli_dbus_daemon_connect_to_name_owner_changed (
 366       priv->dbus,
 367       account_manager_name_owner_changed_cb,
 368       TP_ACCOUNT_MANAGER_BUS_NAME,
 369       NULL,
 370       G_OBJECT (manager),
 371       NULL);
 372
 373   /* trigger MC5 starting */
 374   mc5_proxy = g_object_new (TP_TYPE_PROXY,
 375     "dbus-daemon", priv->dbus,
 376     "dbus-connection", tp_proxy_get_dbus_connection (TP_PROXY (priv->dbus)),
 377     "bus-name", MC5_BUS_NAME,
 378     "object-path", "/",
 379     NULL);
 380
 381   tp_cli_dbus_peer_call_ping (mc5_proxy, -1, NULL, NULL, NULL, NULL);
 382
 383   g_object_unref (mc5_proxy);
 384 }
 385
 386 static void
 387 do_finalize (GObject *obj)
 388 {
 389   EmpathyAccountManager *manager = EMPATHY_ACCOUNT_MANAGER (obj);
 390   EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
 391
 392   g_hash_table_destroy (priv->accounts);
 393
 394   G_OBJECT_CLASS (empathy_account_manager_parent_class)->finalize (obj);
 395 }
 396
 397 static void
 398 do_dispose (GObject *obj)
 399 {
 400   EmpathyAccountManager *manager = EMPATHY_ACCOUNT_MANAGER (obj);
 401   EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
 402
 403   if (priv->dispose_run)
 404     return;
 405
 406   priv->dispose_run = TRUE;
 407
 408   if (priv->dbus == NULL)
 409     g_object_unref (priv->dbus);
 410   priv->dbus = NULL;
 411
 412   G_OBJECT_CLASS (empathy_account_manager_parent_class)->dispose (obj);
 413 }
 414
 415 static GObject *
 416 do_constructor (GType type,
 417                 guint n_construct_params,
 418                 GObjectConstructParam *construct_params)
 419 {
 420   GObject *retval;
 421
 422   if (!manager_singleton)
 423     {
 424       retval = G_OBJECT_CLASS (empathy_account_manager_parent_class)->constructor (type,
 425                                                                                    n_construct_params,
 426                                                                                    construct_params);
 427       manager_singleton = EMPATHY_ACCOUNT_MANAGER (retval);
 428       g_object_add_weak_pointer (retval, (gpointer) &manager_singleton);
 429     }
 430   else
 431     {
 432       retval = g_object_ref (manager_singleton);
 433     }
 434
 435   return retval;
 436 }
 437
 438 static void
 439 do_get_property (GObject *object,
 440     guint prop_id,
 441     GValue *value,
 442     GParamSpec *pspec)
 443 {
 444   EmpathyAccountManager *manager = EMPATHY_ACCOUNT_MANAGER (object);
 445   EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
 446
 447   switch (prop_id)
 448     {
 449       case PROP_READY:
 450         g_value_set_boolean (value, priv->ready);
 451         break;
 452       default:
 453         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 454         break;
 455     }
 456 }
 457
 458 static void
 459 empathy_account_manager_class_init (EmpathyAccountManagerClass *klass)
 460 {
 461   GObjectClass *oclass = G_OBJECT_CLASS (klass);
 462
 463   oclass->finalize = do_finalize;
 464   oclass->dispose = do_dispose;
 465   oclass->constructor = do_constructor;
 466   oclass->get_property = do_get_property;
 467
 468   g_object_class_install_property (oclass, PROP_READY,
 469     g_param_spec_boolean ("ready",
 470       "Ready",
 471       "Whether the initial state dump from the account manager is finished",
 472       FALSE,
 473       G_PARAM_STATIC_STRINGS | G_PARAM_READABLE));
 474
 475   signals[ACCOUNT_CREATED] =
 476     g_signal_new ("account-created",
 477                   G_TYPE_FROM_CLASS (klass),
 478                   G_SIGNAL_RUN_LAST,
 479                   0,
 480                   NULL, NULL,
 481                   g_cclosure_marshal_VOID__OBJECT,
 482                   G_TYPE_NONE,
 483                   1, EMPATHY_TYPE_ACCOUNT);
 484
 485   signals[ACCOUNT_DELETED] =
 486     g_signal_new ("account-deleted",
 487                   G_TYPE_FROM_CLASS (klass),
 488                   G_SIGNAL_RUN_LAST,
 489                   0,
 490                   NULL, NULL,
 491                   g_cclosure_marshal_VOID__OBJECT,
 492                   G_TYPE_NONE,
 493                   1, EMPATHY_TYPE_ACCOUNT);
 494
 495   signals[ACCOUNT_ENABLED] =
 496     g_signal_new ("account-enabled",
 497                   G_TYPE_FROM_CLASS (klass),
 498                   G_SIGNAL_RUN_LAST,
 499                   0,
 500                   NULL, NULL,
 501                   g_cclosure_marshal_VOID__OBJECT,
 502                   G_TYPE_NONE,
 503                   1, EMPATHY_TYPE_ACCOUNT);
 504
 505   signals[ACCOUNT_DISABLED] =
 506     g_signal_new ("account-disabled",
 507                   G_TYPE_FROM_CLASS (klass),
 508                   G_SIGNAL_RUN_LAST,
 509                   0,
 510                   NULL, NULL,
 511                   g_cclosure_marshal_VOID__OBJECT,
 512                   G_TYPE_NONE,
 513                   1, EMPATHY_TYPE_ACCOUNT);
 514
 515   signals[ACCOUNT_CHANGED] =
 516     g_signal_new ("account-changed",
 517                   G_TYPE_FROM_CLASS (klass),
 518                   G_SIGNAL_RUN_LAST,
 519                   0,
 520                   NULL, NULL,
 521                   g_cclosure_marshal_VOID__OBJECT,
 522                   G_TYPE_NONE,
 523                   1, EMPATHY_TYPE_ACCOUNT);
 524
 525   signals[ACCOUNT_CONNECTION_CHANGED] =
 526     g_signal_new ("account-connection-changed",
 527                   G_TYPE_FROM_CLASS (klass),
 528                   G_SIGNAL_RUN_LAST,
 529                   0,
 530                   NULL, NULL,
 531                   _empathy_marshal_VOID__OBJECT_INT_UINT_UINT,
 532                   G_TYPE_NONE,
 533                   4, EMPATHY_TYPE_ACCOUNT,
 534                   G_TYPE_INT,   /* reason */
 535                   G_TYPE_UINT,  /* actual connection */
 536                   G_TYPE_UINT); /* previous connection */
 537
 538   signals[GLOBAL_PRESENCE_CHANGED] =
 539     g_signal_new ("global-presence-changed",
 540                   G_TYPE_FROM_CLASS (klass),
 541                   G_SIGNAL_RUN_LAST,
 542                   0,
 543                   NULL, NULL,
 544                   _empathy_marshal_VOID__UINT_STRING_STRING,
 545                   G_TYPE_NONE,
 546                   3, G_TYPE_UINT, /* Presence type */
 547                   G_TYPE_STRING,  /* status */
 548                   G_TYPE_STRING); /* stauts message*/
 549
 550   signals[NEW_CONNECTION] =
 551     g_signal_new ("new-connection",
 552                   G_TYPE_FROM_CLASS (klass),
 553                   G_SIGNAL_RUN_LAST,
 554                   0,
 555                   NULL, NULL,
 556                   g_cclosure_marshal_VOID__OBJECT,
 557                   G_TYPE_NONE,
 558                   1, TP_TYPE_CONNECTION);
 559
 560   g_type_class_add_private (oclass, sizeof (EmpathyAccountManagerPriv));
 561 }
 562
 563 /* public methods */
 564
 565 EmpathyAccountManager *
 566 empathy_account_manager_dup_singleton (void)
 567 {
 568   return g_object_new (EMPATHY_TYPE_ACCOUNT_MANAGER, NULL);
 569 }
 570
 571 gboolean
 572 empathy_account_manager_is_ready (EmpathyAccountManager *manager)
 573 {
 574   EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
 575
 576   return priv->ready;
 577 }
 578
 579 int
 580 empathy_account_manager_get_connected_accounts (EmpathyAccountManager *manager)
 581 {
 582   EmpathyAccountManagerPriv *priv;
 583
 584   g_return_val_if_fail (EMPATHY_IS_ACCOUNT_MANAGER (manager), 0);
 585
 586   priv = GET_PRIV (manager);
 587
 588   return priv->connected;
 589 }
 590
 591 int
 592 empathy_account_manager_get_connecting_accounts (EmpathyAccountManager *manager)
 593 {
 594   EmpathyAccountManagerPriv *priv;
 595
 596   g_return_val_if_fail (EMPATHY_IS_ACCOUNT_MANAGER (manager), 0);
 597
 598   priv = GET_PRIV (manager);
 599
 600   return priv->connecting;
 601 }
 602
 603 /**
 604  * empathy_account_manager_get_count:
 605  * @manager: a #EmpathyAccountManager
 606  *
 607  * Get the number of accounts.
 608  *
 609  * Returns: the number of accounts.
 610  **/
 611 int
 612 empathy_account_manager_get_count (EmpathyAccountManager *manager)
 613 {
 614   EmpathyAccountManagerPriv *priv;
 615
 616   g_return_val_if_fail (EMPATHY_IS_ACCOUNT_MANAGER (manager), 0);
 617
 618   priv = GET_PRIV (manager);
 619
 620   return g_hash_table_size (priv->accounts);
 621 }
 622
 623 EmpathyAccount *
 624 empathy_account_manager_get_account (EmpathyAccountManager *manager,
 625                                      TpConnection          *connection)
 626 {
 627   EmpathyAccountManagerPriv *priv;
 628   GHashTableIter iter;
 629   gpointer value;
 630
 631   g_return_val_if_fail (EMPATHY_IS_ACCOUNT_MANAGER (manager), 0);
 632
 633   priv = GET_PRIV (manager);
 634
 635   g_hash_table_iter_init (&iter, priv->accounts);
 636   while (g_hash_table_iter_next (&iter, NULL, &value))
 637     {
 638       EmpathyAccount *account = EMPATHY_ACCOUNT (value);
 639
 640       if (connection == empathy_account_get_connection (account))
 641           return account;
 642     }
 643
 644   return NULL;
 645 }
 646
 647 EmpathyAccount *
 648 empathy_account_manager_lookup (EmpathyAccountManager *manager,
 649     const gchar *unique_name)
 650 {
 651   EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
 652   EmpathyAccount *account;
 653
 654   account = g_hash_table_lookup (priv->accounts, unique_name);
 655
 656   if (account != NULL)
 657     g_object_ref (account);
 658
 659   return account;
 660 }
 661
 662 GList *
 663 empathy_account_manager_dup_accounts (EmpathyAccountManager *manager)
 664 {
 665   EmpathyAccountManagerPriv *priv;
 666   GList *ret;
 667
 668   g_return_val_if_fail (EMPATHY_IS_ACCOUNT_MANAGER (manager), NULL);
 669
 670   priv = GET_PRIV (manager);
 671
 672   ret = g_hash_table_get_values (priv->accounts);
 673   g_list_foreach (ret, (GFunc) g_object_ref, NULL);
 674
 675   return ret;
 676 }
 677
 678 /**
 679  * empathy_account_manager_dup_connections:
 680  * @manager: a #EmpathyAccountManager
 681  *
 682  * Get a #GList of all ready #TpConnection. The list must be freed with
 683  * g_list_free, and its elements must be unreffed.
 684  *
 685  * Returns: the list of connections
 686  **/
 687 GList *
 688 empathy_account_manager_dup_connections (EmpathyAccountManager *manager)
 689 {
 690   EmpathyAccountManagerPriv *priv;
 691   GHashTableIter iter;
 692   gpointer value;
 693   GList *ret = NULL;
 694
 695   g_return_val_if_fail (EMPATHY_IS_ACCOUNT_MANAGER (manager), NULL);
 696
 697   priv = GET_PRIV (manager);
 698
 699   g_hash_table_iter_init (&iter, priv->accounts);
 700   while (g_hash_table_iter_next (&iter, NULL, &value))
 701     {
 702       EmpathyAccount *account = EMPATHY_ACCOUNT (value);
 703       TpConnection *connection;
 704
 705       connection = empathy_account_get_connection (account);
 706       if (connection != NULL)
 707         ret = g_list_prepend (ret, g_object_ref (connection));
 708     }
 709
 710   return ret;
 711 }
 712
 713 void
 714 empathy_account_manager_remove (EmpathyAccountManager *manager,
 715     EmpathyAccount *account)
 716 {
 717   /* FIXME */
 718 }
 719
 720
 721 void
 722 empathy_account_manager_request_global_presence (
 723   EmpathyAccountManager *manager,
 724   TpConnectionPresenceType type,
 725   const gchar *status,
 726   const gchar *message)
 727 {
 728   /* FIXME should remember requested presence and set it on new accounts
 729      as well */
 730   EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
 731   GHashTableIter iter;
 732   gpointer value;
 733
 734   g_hash_table_iter_init (&iter, priv->accounts);
 735   while (g_hash_table_iter_next (&iter, NULL, &value))
 736     {
 737       EmpathyAccount *account = EMPATHY_ACCOUNT (value);
 738       gboolean ready;
 739
 740       g_object_get (account, "ready", &ready, NULL);
 741
 742       if (ready)
 743         empathy_account_request_presence (account, type, status, message);
 744     }
 745 }
 746
 747 TpConnectionPresenceType
 748 empathy_account_manager_get_global_presence (
 749   EmpathyAccountManager *manager,
 750   gchar **status,
 751   gchar **message)
 752 {
 753   EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
 754
 755   if (status != NULL)
 756     *status = g_strdup (priv->global_status);
 757   if (message != NULL)
 758     *message = g_strdup (priv->global_status_message);
 759
 760   return priv->global_presence;
 761 }
 762
 763 static void
 764 empathy_account_manager_created_ready_cb (EmpathyAccount *account,
 765   GParamSpec *spec, gpointer user_data)
 766 {
 767   GSimpleAsyncResult *result = G_SIMPLE_ASYNC_RESULT (user_data);
 768
 769   if (!empathy_account_is_ready (account))
 770     return;
 771
 772   g_simple_async_result_set_op_res_gpointer (
 773     G_SIMPLE_ASYNC_RESULT (result), account, NULL);
 774
 775   g_simple_async_result_complete (result);
 776   g_object_unref (G_OBJECT (result));
 777 }
 778
 779 static void
 780 empathy_account_manager_created_cb (TpAccountManager *proxy,
 781     const gchar *account_path,
 782     const GError *error,
 783     gpointer user_data,
 784     GObject *weak_object)
 785 {
 786   EmpathyAccountManager *manager = EMPATHY_ACCOUNT_MANAGER (weak_object);
 787   GSimpleAsyncResult *result = G_SIMPLE_ASYNC_RESULT (user_data);
 788   EmpathyAccount *account;
 789
 790   if (error != NULL)
 791     {
 792       g_simple_async_result_set_from_error (result, (GError *) error);
 793       g_simple_async_result_complete (result);
 794       g_object_unref (G_OBJECT (result));
 795       return;
 796     }
 797
 798   account = account_manager_add_account (manager, account_path);
 799   g_signal_connect (account, "notify::ready",
 800     G_CALLBACK (empathy_account_manager_created_ready_cb), result);
 801 }
 802
 803 void
 804 empathy_account_manager_create_account_async (EmpathyAccountManager *manager,
 805   const gchar *connection_manager,
 806   const gchar *protocol, const gchar *display_name,
 807   GHashTable *parameters, GHashTable *properties,
 808   GAsyncReadyCallback callback, gpointer user_data)
 809 {
 810   EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
 811   GSimpleAsyncResult *result = g_simple_async_result_new (G_OBJECT (manager),
 812       callback, user_data, empathy_account_manager_create_account_finish);
 813
 814   tp_cli_account_manager_call_create_account (priv->tp_manager,
 815       -1,
 816       connection_manager,
 817       protocol,
 818       display_name,
 819       parameters,
 820       properties,
 821       empathy_account_manager_created_cb,
 822       result,
 823       NULL,
 824       G_OBJECT (manager));
 825 }
 826
 827 EmpathyAccount *
 828 empathy_account_manager_create_account_finish (
 829   EmpathyAccountManager *manager, GAsyncResult *result, GError **error)
 830 {
 831   if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result),
 832       error))
 833     return NULL;
 834
 835   g_return_val_if_fail (g_simple_async_result_is_valid (result,
 836     G_OBJECT (manager), empathy_account_manager_create_account_finish), NULL);
 837
 838   return EMPATHY_ACCOUNT (g_simple_async_result_get_op_res_gpointer (
 839     G_SIMPLE_ASYNC_RESULT (result)));
 840 }
 841