libempathy/empathy-account-settings.c

   1 /*
   2  * empathy-account-settings.c - Source for EmpathyAccountSettings
   3  * Copyright (C) 2009 Collabora Ltd.
   4  * @author Sjoerd Simons <sjoerd.simons@collabora.co.uk>
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  19  */
  20
  21 #include "config.h"
  22
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25
  26 #include <telepathy-glib/account-manager.h>
  27 #include <telepathy-glib/util.h>
  28 #include <telepathy-glib/interfaces.h>
  29 #include <telepathy-glib/gtypes.h>
  30
  31 #include "empathy-account-settings.h"
  32 #include "empathy-connection-managers.h"
  33 #include "empathy-keyring.h"
  34 #include "empathy-utils.h"
  35 #include "empathy-presence-manager.h"
  36
  37 #define DEBUG_FLAG EMPATHY_DEBUG_ACCOUNT
  38 #include <libempathy/empathy-debug.h>
  39
  40 #define GET_PRIV(obj) EMPATHY_GET_PRIV (obj, EmpathyAccountSettings)
  41
  42 G_DEFINE_TYPE(EmpathyAccountSettings, empathy_account_settings, G_TYPE_OBJECT)
  43
  44 enum {
  45   PROP_ACCOUNT = 1,
  46   PROP_CM_NAME,
  47   PROP_PROTOCOL,
  48   PROP_SERVICE,
  49   PROP_DISPLAY_NAME,
  50   PROP_DISPLAY_NAME_OVERRIDDEN,
  51   PROP_READY
  52 };
  53
  54 enum {
  55   PASSWORD_RETRIEVED = 1,
  56   LAST_SIGNAL
  57 };
  58
  59 static gulong signals[LAST_SIGNAL] = { 0, };
  60
  61 /* private structure */
  62 typedef struct _EmpathyAccountSettingsPriv EmpathyAccountSettingsPriv;
  63
  64 struct _EmpathyAccountSettingsPriv
  65 {
  66   gboolean dispose_has_run;
  67   EmpathyConnectionManagers *managers;
  68   TpAccountManager *account_manager;
  69
  70   TpConnectionManager *manager;
  71   TpProtocol *protocol_obj;
  72
  73   TpAccount *account;
  74   gchar *cm_name;
  75   gchar *protocol;
  76   gchar *service;
  77   gchar *display_name;
  78   gchar *icon_name;
  79   gboolean display_name_overridden;
  80   gboolean ready;
  81
  82   gboolean supports_sasl;
  83   gboolean password_changed;
  84
  85   gchar *password;
  86   gchar *password_original;
  87
  88   gboolean password_retrieved;
  89   gboolean password_requested;
  90
  91   /* Parameter name (gchar *) -> parameter value (GVariant) */
  92   GHashTable *parameters;
  93   /* Keys are parameter names from the hash above (gchar *).
  94    * Values are regular expresions that should match corresponding parameter
  95    * values (GRegex *). Possible regexp patterns are defined in
  96    * empathy-account-widget.c */
  97   GHashTable *param_regexps;
  98   GArray *unset_parameters;
  99   GList *required_params;
 100
 101   gulong managers_ready_id;
 102   gboolean preparing_protocol;
 103
 104   /* If TRUE, the account should have 'tel' in its
 105    * Account.Interface.Addressing.URISchemes property. */
 106   gboolean uri_scheme_tel;
 107   /* If TRUE, Service property needs to be updated when applying changes */
 108   gboolean update_service;
 109
 110   GSimpleAsyncResult *apply_result;
 111 };
 112
 113 static void
 114 empathy_account_settings_init (EmpathyAccountSettings *obj)
 115 {
 116   EmpathyAccountSettingsPriv *priv = G_TYPE_INSTANCE_GET_PRIVATE ((obj),
 117     EMPATHY_TYPE_ACCOUNT_SETTINGS, EmpathyAccountSettingsPriv);
 118
 119   obj->priv = priv;
 120
 121   /* allocate any data required by the object here */
 122   priv->managers = empathy_connection_managers_dup_singleton ();
 123   priv->account_manager = tp_account_manager_dup ();
 124
 125   priv->parameters = g_hash_table_new_full (g_str_hash, g_str_equal,
 126     g_free, (GDestroyNotify) g_variant_unref);
 127
 128   priv->param_regexps = g_hash_table_new_full (g_str_hash, g_str_equal,
 129     g_free, (GDestroyNotify) g_regex_unref);
 130
 131   priv->unset_parameters = g_array_new (TRUE, FALSE, sizeof (gchar *));
 132
 133   priv->required_params = NULL;
 134 }
 135
 136 static void empathy_account_settings_dispose (GObject *object);
 137 static void empathy_account_settings_finalize (GObject *object);
 138 static void empathy_account_settings_account_ready_cb (GObject *source_object,
 139     GAsyncResult *result, gpointer user_data);
 140 static void empathy_account_settings_managers_ready_cb (GObject *obj,
 141     GParamSpec *pspec, gpointer user_data);
 142 static void empathy_account_settings_check_readyness (
 143     EmpathyAccountSettings *self);
 144
 145 static void
 146 empathy_account_settings_set_property (GObject *object,
 147     guint prop_id,
 148     const GValue *value,
 149     GParamSpec *pspec)
 150 {
 151   EmpathyAccountSettings *settings = EMPATHY_ACCOUNT_SETTINGS (object);
 152   EmpathyAccountSettingsPriv *priv = GET_PRIV (settings);
 153
 154   switch (prop_id)
 155     {
 156       case PROP_ACCOUNT:
 157         priv->account = g_value_dup_object (value);
 158         break;
 159       case PROP_CM_NAME:
 160         priv->cm_name = g_value_dup_string (value);
 161         break;
 162       case PROP_PROTOCOL:
 163         priv->protocol = g_value_dup_string (value);
 164         break;
 165       case PROP_SERVICE:
 166         priv->service = g_value_dup_string (value);
 167         break;
 168       case PROP_DISPLAY_NAME:
 169         priv->display_name = g_value_dup_string (value);
 170         break;
 171       case PROP_DISPLAY_NAME_OVERRIDDEN:
 172         priv->display_name_overridden = g_value_get_boolean (value);
 173         break;
 174       default:
 175         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 176         break;
 177     }
 178 }
 179
 180 static void
 181 empathy_account_settings_get_property (GObject *object,
 182     guint prop_id,
 183     GValue *value,
 184     GParamSpec *pspec)
 185 {
 186   EmpathyAccountSettings *settings = EMPATHY_ACCOUNT_SETTINGS (object);
 187   EmpathyAccountSettingsPriv *priv = GET_PRIV (settings);
 188
 189   switch (prop_id)
 190     {
 191       case PROP_ACCOUNT:
 192         g_value_set_object (value, priv->account);
 193         break;
 194       case PROP_CM_NAME:
 195         g_value_set_string (value, priv->cm_name);
 196         break;
 197       case PROP_PROTOCOL:
 198         g_value_set_string (value, priv->protocol);
 199         break;
 200       case PROP_SERVICE:
 201         g_value_set_string (value, priv->service);
 202         break;
 203       case PROP_DISPLAY_NAME:
 204         g_value_set_string (value, priv->display_name);
 205         break;
 206       case PROP_DISPLAY_NAME_OVERRIDDEN:
 207         g_value_set_boolean (value, priv->display_name_overridden);
 208         break;
 209       case PROP_READY:
 210         g_value_set_boolean (value, priv->ready);
 211         break;
 212       default:
 213         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 214         break;
 215     }
 216 }
 217
 218 static void
 219 empathy_account_settings_constructed (GObject *object)
 220 {
 221   EmpathyAccountSettings *self = EMPATHY_ACCOUNT_SETTINGS (object);
 222   EmpathyAccountSettingsPriv *priv = GET_PRIV (self);
 223
 224   if (priv->account != NULL)
 225     {
 226       g_free (priv->cm_name);
 227       g_free (priv->protocol);
 228       g_free (priv->service);
 229
 230       priv->cm_name =
 231         g_strdup (tp_account_get_connection_manager (priv->account));
 232       priv->protocol =
 233         g_strdup (tp_account_get_protocol (priv->account));
 234       priv->service =
 235         g_strdup (tp_account_get_service (priv->account));
 236       priv->icon_name = g_strdup
 237         (tp_account_get_icon_name (priv->account));
 238     }
 239   else
 240     {
 241       priv->icon_name = empathy_protocol_icon_name (priv->protocol);
 242     }
 243
 244   g_assert (priv->cm_name != NULL && priv->protocol != NULL);
 245
 246   empathy_account_settings_check_readyness (self);
 247
 248   if (!priv->ready)
 249     {
 250       GQuark features[] = {
 251           TP_ACCOUNT_FEATURE_CORE,
 252           TP_ACCOUNT_FEATURE_STORAGE,
 253           TP_ACCOUNT_FEATURE_ADDRESSING,
 254           0 };
 255
 256       if (priv->account != NULL)
 257         {
 258           tp_proxy_prepare_async (priv->account, features,
 259               empathy_account_settings_account_ready_cb, self);
 260         }
 261
 262       tp_g_signal_connect_object (priv->managers, "notify::ready",
 263         G_CALLBACK (empathy_account_settings_managers_ready_cb), object, 0);
 264     }
 265
 266   if (G_OBJECT_CLASS (
 267         empathy_account_settings_parent_class)->constructed != NULL)
 268     G_OBJECT_CLASS (
 269         empathy_account_settings_parent_class)->constructed (object);
 270 }
 271
 272
 273 static void
 274 empathy_account_settings_class_init (
 275     EmpathyAccountSettingsClass *empathy_account_settings_class)
 276 {
 277   GObjectClass *object_class = G_OBJECT_CLASS (empathy_account_settings_class);
 278
 279   g_type_class_add_private (empathy_account_settings_class, sizeof
 280       (EmpathyAccountSettingsPriv));
 281
 282   object_class->dispose = empathy_account_settings_dispose;
 283   object_class->finalize = empathy_account_settings_finalize;
 284   object_class->set_property = empathy_account_settings_set_property;
 285   object_class->get_property = empathy_account_settings_get_property;
 286   object_class->constructed = empathy_account_settings_constructed;
 287
 288   g_object_class_install_property (object_class, PROP_ACCOUNT,
 289     g_param_spec_object ("account",
 290       "Account",
 291       "The TpAccount backing these settings",
 292       TP_TYPE_ACCOUNT,
 293       G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
 294
 295   g_object_class_install_property (object_class, PROP_CM_NAME,
 296     g_param_spec_string ("connection-manager",
 297       "connection-manager",
 298       "The name of the connection manager this account uses",
 299       NULL,
 300       G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
 301
 302   g_object_class_install_property (object_class, PROP_PROTOCOL,
 303     g_param_spec_string ("protocol",
 304       "Protocol",
 305       "The name of the protocol this account uses",
 306       NULL,
 307       G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
 308
 309   g_object_class_install_property (object_class, PROP_SERVICE,
 310     g_param_spec_string ("service",
 311       "Service",
 312       "The service of this account, or NULL",
 313       NULL,
 314       G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
 315
 316   g_object_class_install_property (object_class, PROP_DISPLAY_NAME,
 317     g_param_spec_string ("display-name",
 318       "display-name",
 319       "The display name account these settings belong to",
 320       NULL,
 321       G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
 322
 323   g_object_class_install_property (object_class, PROP_DISPLAY_NAME_OVERRIDDEN,
 324       g_param_spec_boolean ("display-name-overridden",
 325         "display-name-overridden",
 326         "Whether the display name for this account has been manually "
 327         "overridden",
 328         FALSE,
 329         G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE));
 330
 331   g_object_class_install_property (object_class, PROP_READY,
 332     g_param_spec_boolean ("ready",
 333       "Ready",
 334       "Whether this account is ready to be used",
 335       FALSE,
 336       G_PARAM_STATIC_STRINGS | G_PARAM_READABLE));
 337
 338   signals[PASSWORD_RETRIEVED] =
 339       g_signal_new ("password-retrieved",
 340           G_TYPE_FROM_CLASS (empathy_account_settings_class),
 341           G_SIGNAL_RUN_LAST, 0, NULL, NULL,
 342           g_cclosure_marshal_generic,
 343           G_TYPE_NONE, 0);
 344 }
 345
 346 static void
 347 empathy_account_settings_dispose (GObject *object)
 348 {
 349   EmpathyAccountSettings *self = EMPATHY_ACCOUNT_SETTINGS (object);
 350   EmpathyAccountSettingsPriv *priv = GET_PRIV (self);
 351
 352   if (priv->dispose_has_run)
 353     return;
 354
 355   priv->dispose_has_run = TRUE;
 356
 357   if (priv->managers_ready_id != 0)
 358     g_signal_handler_disconnect (priv->managers, priv->managers_ready_id);
 359   priv->managers_ready_id = 0;
 360
 361   tp_clear_object (&priv->managers);
 362   tp_clear_object (&priv->manager);
 363   tp_clear_object (&priv->account_manager);
 364   tp_clear_object (&priv->account);
 365   tp_clear_object (&priv->protocol_obj);
 366
 367   /* release any references held by the object here */
 368   if (G_OBJECT_CLASS (empathy_account_settings_parent_class)->dispose)
 369     G_OBJECT_CLASS (empathy_account_settings_parent_class)->dispose (object);
 370 }
 371
 372 static void
 373 empathy_account_settings_free_unset_parameters (
 374     EmpathyAccountSettings *settings)
 375 {
 376   EmpathyAccountSettingsPriv *priv = GET_PRIV (settings);
 377   guint i;
 378
 379   for (i = 0 ; i < priv->unset_parameters->len; i++)
 380     g_free (g_array_index (priv->unset_parameters, gchar *, i));
 381
 382   g_array_set_size (priv->unset_parameters, 0);
 383 }
 384
 385 static void
 386 empathy_account_settings_finalize (GObject *object)
 387 {
 388   EmpathyAccountSettings *self = EMPATHY_ACCOUNT_SETTINGS (object);
 389   EmpathyAccountSettingsPriv *priv = GET_PRIV (self);
 390   GList *l;
 391
 392   /* free any data held directly by the object here */
 393   g_free (priv->cm_name);
 394   g_free (priv->protocol);
 395   g_free (priv->service);
 396   g_free (priv->display_name);
 397   g_free (priv->icon_name);
 398   g_free (priv->password);
 399   g_free (priv->password_original);
 400
 401   if (priv->required_params != NULL)
 402     {
 403       for (l = priv->required_params; l; l = l->next)
 404         g_free (l->data);
 405       g_list_free (priv->required_params);
 406     }
 407
 408   g_hash_table_unref (priv->parameters);
 409   g_hash_table_unref (priv->param_regexps);
 410
 411   empathy_account_settings_free_unset_parameters (self);
 412   g_array_unref (priv->unset_parameters);
 413
 414   G_OBJECT_CLASS (empathy_account_settings_parent_class)->finalize (object);
 415 }
 416
 417 static void
 418 empathy_account_settings_protocol_obj_prepared_cb (GObject *source,
 419     GAsyncResult *result,
 420     gpointer user_data)
 421 {
 422   EmpathyAccountSettings *self = user_data;
 423   GError *error = NULL;
 424
 425   if (!tp_proxy_prepare_finish (source, result, &error))
 426     {
 427       DEBUG ("Failed to prepare protocol object: %s", error->message);
 428       g_clear_error (&error);
 429       return;
 430     }
 431
 432   empathy_account_settings_check_readyness (self);
 433 }
 434
 435 static void
 436 empathy_account_settings_get_password_cb (GObject *source,
 437     GAsyncResult *result,
 438     gpointer user_data)
 439 {
 440   EmpathyAccountSettings *self = user_data;
 441   EmpathyAccountSettingsPriv *priv = GET_PRIV (self);
 442   const gchar *password;
 443   GError *error = NULL;
 444
 445   password = empathy_keyring_get_account_password_finish (TP_ACCOUNT (source),
 446       result, &error);
 447
 448   if (error != NULL)
 449     {
 450       DEBUG ("Failed to get password: %s", error->message);
 451       g_clear_error (&error);
 452     }
 453
 454   /* It doesn't really matter if getting the password failed; that
 455    * just means that it's not there, or let's act like that at
 456    * least. */
 457
 458   g_assert (priv->password == NULL);
 459
 460   priv->password = g_strdup (password);
 461   priv->password_original = g_strdup (password);
 462
 463   g_signal_emit (self, signals[PASSWORD_RETRIEVED], 0);
 464 }
 465
 466 static void
 467 empathy_account_settings_migrate_password_cb (GObject *source,
 468     GAsyncResult *result,
 469     gpointer user_data)
 470 {
 471   TpAccount *account = TP_ACCOUNT (source);
 472   GError *error = NULL;
 473   EmpathyAccountSettings *self = user_data;
 474   EmpathyAccountSettingsPriv *priv = GET_PRIV (self);
 475   GHashTable *empty;
 476   const gchar *unset[] = { "password", NULL };
 477
 478   if (!empathy_keyring_set_account_password_finish (account, result, &error))
 479     {
 480       DEBUG ("Failed to set password: %s", error->message);
 481       g_clear_error (&error);
 482       return;
 483     }
 484
 485   /* Now clear the password MC has stored. */
 486   empty = tp_asv_new (NULL, NULL);
 487   tp_account_update_parameters_async (priv->account,
 488       empty, unset, NULL, NULL);
 489
 490   g_hash_table_remove (priv->parameters, "password");
 491
 492   g_hash_table_unref (empty);
 493 }
 494
 495 static GVariant * empathy_account_settings_dup (
 496     EmpathyAccountSettings *settings,
 497     const gchar *param);
 498
 499 static void
 500 empathy_account_settings_try_migrating_password (EmpathyAccountSettings *self)
 501 {
 502   EmpathyAccountSettingsPriv *priv = GET_PRIV (self);
 503   GVariant *v;
 504   const gchar *password;
 505
 506   v = empathy_account_settings_dup (self, "password");
 507   if (v == NULL)
 508     return;
 509
 510   if (!priv->supports_sasl)
 511     goto out;
 512
 513   /* mission-control still has our password, although the CM
 514    * supports SASL. Let's try migrating it. */
 515
 516   DEBUG ("Trying to migrate password parameter from MC to the "
 517       "keyring ourselves for account %s",
 518       tp_account_get_path_suffix (priv->account));
 519
 520   /* I can't imagine why this would fail. */
 521   if (!g_variant_is_of_type (v, G_VARIANT_TYPE_STRING))
 522     goto out;
 523
 524   password = g_variant_get_string (v, NULL);
 525
 526   if (EMP_STR_EMPTY (password))
 527     goto out;
 528
 529   empathy_keyring_set_account_password_async (priv->account, password,
 530       empathy_account_settings_migrate_password_cb, self);
 531
 532   /* We don't want to request the password again, we
 533    * already know it. */
 534   priv->password_requested = TRUE;
 535
 536   priv->password = g_strdup (password);
 537   priv->password_original = g_strdup (password);
 538
 539 out:
 540   g_variant_unref (v);
 541 }
 542
 543 static void
 544 empathy_account_settings_check_readyness (EmpathyAccountSettings *self)
 545 {
 546   EmpathyAccountSettingsPriv *priv = GET_PRIV (self);
 547   GQuark features[] = { TP_PROTOCOL_FEATURE_CORE, 0 };
 548
 549   if (priv->ready)
 550     return;
 551
 552   if (priv->account != NULL
 553       && !tp_account_is_prepared (priv->account, TP_ACCOUNT_FEATURE_CORE))
 554       return;
 555
 556   if (!empathy_connection_managers_is_ready (priv->managers))
 557     return;
 558
 559   if (priv->manager == NULL)
 560     {
 561       priv->manager = empathy_connection_managers_get_cm (
 562           priv->managers, priv->cm_name);
 563     }
 564
 565   if (priv->manager == NULL)
 566     return;
 567
 568   g_object_ref (priv->manager);
 569
 570   if (priv->account != NULL)
 571     {
 572       g_free (priv->display_name);
 573       priv->display_name =
 574         g_strdup (tp_account_get_display_name (priv->account));
 575
 576       g_free (priv->icon_name);
 577       priv->icon_name =
 578         g_strdup (tp_account_get_icon_name (priv->account));
 579
 580       priv->uri_scheme_tel = empathy_account_has_uri_scheme_tel (priv->account);
 581     }
 582
 583   if (priv->protocol_obj == NULL)
 584     {
 585       priv->protocol_obj = g_object_ref (
 586           tp_connection_manager_get_protocol_object (priv->manager,
 587             priv->protocol));
 588     }
 589
 590   if (!tp_proxy_is_prepared (priv->protocol_obj, TP_PROTOCOL_FEATURE_CORE)
 591       && !priv->preparing_protocol)
 592     {
 593       priv->preparing_protocol = TRUE;
 594       tp_proxy_prepare_async (priv->protocol_obj, features,
 595           empathy_account_settings_protocol_obj_prepared_cb, self);
 596       return;
 597     }
 598   else
 599     {
 600       if (tp_strv_contains (tp_protocol_get_authentication_types (
 601                   priv->protocol_obj),
 602               TP_IFACE_CHANNEL_INTERFACE_SASL_AUTHENTICATION))
 603         {
 604           priv->supports_sasl = TRUE;
 605         }
 606     }
 607
 608   if (priv->required_params == NULL)
 609     {
 610       GList *params, *l;
 611
 612       params = tp_protocol_dup_params (priv->protocol_obj);
 613       for (l = params; l != NULL; l = g_list_next (l))
 614         {
 615           TpConnectionManagerParam *cur = l->data;
 616
 617           if (tp_connection_manager_param_is_required (cur))
 618             {
 619               priv->required_params = g_list_append (priv->required_params,
 620                   g_strdup (tp_connection_manager_param_get_name (cur)));
 621             }
 622         }
 623
 624        g_list_free_full (params,
 625            (GDestroyNotify) tp_connection_manager_param_free);
 626     }
 627
 628   /* NOTE: When removing MC migration code, remove this call, and the
 629    * function it's calling. That's it. */
 630   empathy_account_settings_try_migrating_password (self);
 631
 632   /* priv->account won't be a proper account if it's the account
 633    * assistant showing this widget. */
 634   if (priv->supports_sasl && !priv->password_requested
 635       && priv->account != NULL)
 636     {
 637       priv->password_requested = TRUE;
 638
 639       /* Make this call but don't block on its readiness. We'll signal
 640        * if it's updated later with ::password-retrieved. */
 641       empathy_keyring_get_account_password_async (priv->account,
 642           empathy_account_settings_get_password_cb, self);
 643     }
 644
 645   priv->ready = TRUE;
 646   g_object_notify (G_OBJECT (self), "ready");
 647 }
 648
 649 static void
 650 empathy_account_settings_account_ready_cb (GObject *source_object,
 651     GAsyncResult *result,
 652     gpointer user_data)
 653 {
 654   EmpathyAccountSettings *settings = EMPATHY_ACCOUNT_SETTINGS (user_data);
 655   TpAccount *account = TP_ACCOUNT (source_object);
 656   GError *error = NULL;
 657
 658   if (!tp_proxy_prepare_finish (account, result, &error))
 659     {
 660       DEBUG ("Failed to prepare account: %s", error->message);
 661       g_error_free (error);
 662       return;
 663     }
 664
 665   empathy_account_settings_check_readyness (settings);
 666 }
 667
 668 static void
 669 empathy_account_settings_managers_ready_cb (GObject *object,
 670     GParamSpec *pspec,
 671     gpointer user_data)
 672 {
 673   EmpathyAccountSettings *settings = EMPATHY_ACCOUNT_SETTINGS (user_data);
 674
 675   empathy_account_settings_check_readyness (settings);
 676 }
 677
 678 EmpathyAccountSettings *
 679 empathy_account_settings_new (const gchar *connection_manager,
 680     const gchar *protocol,
 681     const gchar *service,
 682     const char *display_name)
 683 {
 684   return g_object_new (EMPATHY_TYPE_ACCOUNT_SETTINGS,
 685       "connection-manager", connection_manager,
 686       "protocol", protocol,
 687       "service", service,
 688       "display-name", display_name,
 689       NULL);
 690 }
 691
 692 EmpathyAccountSettings *
 693 empathy_account_settings_new_for_account (TpAccount *account)
 694 {
 695   return g_object_new (EMPATHY_TYPE_ACCOUNT_SETTINGS,
 696       "account", account,
 697       NULL);
 698 }
 699
 700 GList *
 701 empathy_account_settings_dup_tp_params (EmpathyAccountSettings *settings)
 702 {
 703   EmpathyAccountSettingsPriv *priv = GET_PRIV (settings);
 704
 705   g_return_val_if_fail (priv->protocol_obj != NULL, NULL);
 706
 707   return tp_protocol_dup_params (priv->protocol_obj);
 708 }
 709
 710 gboolean
 711 empathy_account_settings_is_ready (EmpathyAccountSettings *settings)
 712 {
 713   EmpathyAccountSettingsPriv *priv = GET_PRIV (settings);
 714
 715   return priv->ready;
 716 }
 717
 718 const gchar *
 719 empathy_account_settings_get_cm (EmpathyAccountSettings *settings)
 720 {
 721   EmpathyAccountSettingsPriv *priv = GET_PRIV (settings);
 722
 723   return priv->cm_name;
 724 }
 725
 726 const gchar *
 727 empathy_account_settings_get_protocol (EmpathyAccountSettings *settings)
 728 {
 729   EmpathyAccountSettingsPriv *priv = GET_PRIV (settings);
 730
 731   return priv->protocol;
 732 }
 733
 734 const gchar *
 735 empathy_account_settings_get_service (EmpathyAccountSettings *settings)
 736 {
 737   EmpathyAccountSettingsPriv *priv = GET_PRIV (settings);
 738
 739   return priv->service;
 740 }
 741
 742 void
 743 empathy_account_settings_set_service (EmpathyAccountSettings *settings,
 744     const gchar *service)
 745 {
 746   EmpathyAccountSettingsPriv *priv = GET_PRIV (settings);
 747
 748   if (!tp_strdiff (priv->service, service))
 749     return;
 750
 751   g_free (priv->service);
 752   priv->service = g_strdup (service);
 753   g_object_notify (G_OBJECT (settings), "service");
 754   priv->update_service = TRUE;
 755 }
 756
 757 gchar *
 758 empathy_account_settings_get_icon_name (EmpathyAccountSettings *settings)
 759 {
 760   EmpathyAccountSettingsPriv *priv = GET_PRIV (settings);
 761
 762   return priv->icon_name;
 763 }
 764
 765 const gchar *
 766 empathy_account_settings_get_display_name (EmpathyAccountSettings *settings)
 767 {
 768   EmpathyAccountSettingsPriv *priv = GET_PRIV (settings);
 769
 770   return priv->display_name;
 771 }
 772
 773 TpAccount *
 774 empathy_account_settings_get_account (EmpathyAccountSettings *settings)
 775 {
 776   EmpathyAccountSettingsPriv *priv = GET_PRIV (settings);
 777
 778   return priv->account;
 779 }
 780
 781 static gboolean
 782 empathy_account_settings_is_unset (EmpathyAccountSettings *settings,
 783     const gchar *param)
 784 {
 785   EmpathyAccountSettingsPriv *priv = GET_PRIV (settings);
 786   GArray *a;
 787   guint i;
 788
 789   a = priv->unset_parameters;
 790
 791   for (i = 0; i < a->len; i++)
 792     {
 793       if (!tp_strdiff (g_array_index (a, gchar *, i), param))
 794         return TRUE;
 795     }
 796
 797   return FALSE;
 798 }
 799
 800 static const TpConnectionManagerParam *
 801 empathy_account_settings_get_tp_param (EmpathyAccountSettings *settings,
 802     const gchar *param)
 803 {
 804   EmpathyAccountSettingsPriv *priv = GET_PRIV (settings);
 805
 806   return tp_protocol_get_param (priv->protocol_obj, param);
 807 }
 808
 809 gboolean
 810 empathy_account_settings_have_tp_param (EmpathyAccountSettings *settings,
 811     const gchar *param)
 812 {
 813   return (empathy_account_settings_get_tp_param (settings, param) != NULL);
 814 }
 815
 816 static void
 817 account_settings_remove_from_unset (EmpathyAccountSettings *settings,
 818     const gchar *param)
 819 {
 820   EmpathyAccountSettingsPriv *priv = GET_PRIV (settings);
 821   guint idx;
 822   gchar *val;
 823
 824   for (idx = 0; idx < priv->unset_parameters->len; idx++)
 825     {
 826       val = g_array_index (priv->unset_parameters, gchar *, idx);
 827
 828       if (!tp_strdiff (val, param))
 829         {
 830           priv->unset_parameters =
 831             g_array_remove_index (priv->unset_parameters, idx);
 832           g_free (val);
 833
 834           break;
 835         }
 836     }
 837 }
 838
 839 GVariant *
 840 empathy_account_settings_dup_default (EmpathyAccountSettings *settings,
 841     const gchar *param)
 842 {
 843   const TpConnectionManagerParam *p;
 844
 845   p = empathy_account_settings_get_tp_param (settings, param);
 846   if (p == NULL)
 847     return NULL;
 848
 849   return tp_connection_manager_param_dup_default_variant (p);
 850 }
 851
 852 const gchar *
 853 empathy_account_settings_get_dbus_signature (EmpathyAccountSettings *settings,
 854     const gchar *param)
 855 {
 856   const TpConnectionManagerParam *p;
 857
 858   p = empathy_account_settings_get_tp_param (settings, param);
 859
 860   if (p == NULL)
 861     return NULL;
 862
 863   return tp_connection_manager_param_get_dbus_signature (p);
 864 }
 865
 866 static GVariant *
 867 empathy_account_settings_dup (EmpathyAccountSettings *settings,
 868     const gchar *param)
 869 {
 870   EmpathyAccountSettingsPriv *priv = GET_PRIV (settings);
 871   GVariant *result;
 872
 873   /* Lookup the update parameters we set */
 874   result = g_hash_table_lookup (priv->parameters, param);
 875   if (result != NULL)
 876     return g_variant_ref (result);
 877
 878   /* If the parameters isn't unset use the accounts setting if any */
 879   if (priv->account != NULL
 880       && !empathy_account_settings_is_unset (settings, param))
 881     {
 882       GVariant *parameters;
 883
 884       parameters = tp_account_dup_parameters_vardict (priv->account);
 885       result = g_variant_lookup_value (parameters, param, NULL);
 886       g_variant_unref (parameters);
 887
 888       if (result != NULL)
 889         /* g_variant_lookup_value() is (transfer full) */
 890         return result;
 891     }
 892
 893   /* fallback to the default */
 894   return empathy_account_settings_dup_default (settings, param);
 895 }
 896
 897 void
 898 empathy_account_settings_unset (EmpathyAccountSettings *settings,
 899     const gchar *param)
 900 {
 901   EmpathyAccountSettingsPriv *priv = GET_PRIV (settings);
 902   gchar *v;
 903   if (empathy_account_settings_is_unset (settings, param))
 904     return;
 905
 906   if (priv->supports_sasl && !tp_strdiff (param, "password"))
 907     {
 908       g_free (priv->password);
 909       priv->password = NULL;
 910       priv->password_changed = TRUE;
 911       return;
 912     }
 913
 914   v = g_strdup (param);
 915
 916   g_array_append_val (priv->unset_parameters, v);
 917   g_hash_table_remove (priv->parameters, param);
 918 }
 919
 920 void
 921 empathy_account_settings_discard_changes (EmpathyAccountSettings *settings)
 922 {
 923   EmpathyAccountSettingsPriv *priv = GET_PRIV (settings);
 924
 925   g_hash_table_remove_all (priv->parameters);
 926   empathy_account_settings_free_unset_parameters (settings);
 927
 928   priv->password_changed = FALSE;
 929   g_free (priv->password);
 930   priv->password = g_strdup (priv->password_original);
 931
 932   if (priv->account != NULL)
 933     priv->uri_scheme_tel = empathy_account_has_uri_scheme_tel (priv->account);
 934   else
 935     priv->uri_scheme_tel = FALSE;
 936 }
 937
 938 gchar *
 939 empathy_account_settings_dup_string (EmpathyAccountSettings *settings,
 940     const gchar *param)
 941 {
 942   EmpathyAccountSettingsPriv *priv = GET_PRIV (settings);
 943   GVariant *v;
 944   gchar *result = NULL;
 945
 946   if (!tp_strdiff (param, "password") && priv->supports_sasl)
 947     {
 948       return g_strdup (priv->password);
 949     }
 950
 951   v = empathy_account_settings_dup (settings, param);
 952   if (v == NULL)
 953     return NULL;
 954
 955   if (g_variant_is_of_type (v, G_VARIANT_TYPE_STRING))
 956     result = g_variant_dup_string (v, NULL);
 957
 958   g_variant_unref (v);
 959   return result;
 960 }
 961
 962 GStrv
 963 empathy_account_settings_dup_strv (EmpathyAccountSettings *settings,
 964     const gchar *param)
 965 {
 966   GVariant *v;
 967   GStrv result = NULL;
 968
 969   v = empathy_account_settings_dup (settings, param);
 970   if (v == NULL)
 971     return NULL;
 972
 973   if (g_variant_is_of_type (v, G_VARIANT_TYPE_STRING_ARRAY))
 974     result = g_variant_dup_strv (v, NULL);
 975
 976   g_variant_unref (v);
 977   return result;
 978 }
 979
 980 gint32
 981 empathy_account_settings_get_int32 (EmpathyAccountSettings *settings,
 982     const gchar *param)
 983 {
 984   GVariant *v;
 985   gint32 ret = 0;
 986
 987   v = empathy_account_settings_dup (settings, param);
 988   if (v == NULL)
 989     return 0;
 990
 991   if (g_variant_is_of_type (v, G_VARIANT_TYPE_BYTE))
 992     ret = g_variant_get_byte (v);
 993   else if (g_variant_is_of_type (v, G_VARIANT_TYPE_INT32))
 994     ret = g_variant_get_int32 (v);
 995   else if (g_variant_is_of_type (v, G_VARIANT_TYPE_UINT32))
 996     ret = CLAMP (g_variant_get_uint32 (v), (guint) G_MININT32,
 997         G_MAXINT32);
 998   else if (g_variant_is_of_type (v, G_VARIANT_TYPE_INT64))
 999     ret = CLAMP (g_variant_get_int64 (v), G_MININT32, G_MAXINT32);
1000   else if (g_variant_is_of_type (v, G_VARIANT_TYPE_UINT64))
1001     ret = CLAMP (g_variant_get_uint64 (v), (guint64) G_MININT32, G_MAXINT32);
1002   else
1003     {
1004       gchar *tmp;
1005
1006       tmp = g_variant_print (v, TRUE);
1007       DEBUG ("Unsupported type for param '%s': %s'", param, tmp);
1008       g_free (tmp);
1009     }
1010
1011   g_variant_unref (v);
1012   return ret;
1013 }
1014
1015 gint64
1016 empathy_account_settings_get_int64 (EmpathyAccountSettings *settings,
1017     const gchar *param)
1018 {
1019   GVariant *v;
1020   gint64 ret = 0;
1021
1022   v = empathy_account_settings_dup (settings, param);
1023   if (v == NULL)
1024     return 0;
1025
1026   if (g_variant_is_of_type (v, G_VARIANT_TYPE_BYTE))
1027     ret = g_variant_get_byte (v);
1028   else if (g_variant_is_of_type (v, G_VARIANT_TYPE_INT32))
1029     ret = g_variant_get_int32 (v);
1030   else if (g_variant_is_of_type (v, G_VARIANT_TYPE_UINT32))
1031     ret = g_variant_get_uint32 (v);
1032   else if (g_variant_is_of_type (v, G_VARIANT_TYPE_INT64))
1033     ret = g_variant_get_int64 (v);
1034   else if (g_variant_is_of_type (v, G_VARIANT_TYPE_UINT64))
1035     ret = CLAMP (g_variant_get_uint64 (v), (guint64) G_MININT64, G_MAXINT64);
1036   else
1037     {
1038       gchar *tmp;
1039
1040       tmp = g_variant_print (v, TRUE);
1041       DEBUG ("Unsupported type for param '%s': %s'", param, tmp);
1042       g_free (tmp);
1043     }
1044
1045   g_variant_unref (v);
1046   return ret;
1047 }
1048
1049 guint32
1050 empathy_account_settings_get_uint32 (EmpathyAccountSettings *settings,
1051     const gchar *param)
1052 {
1053   GVariant *v;
1054   guint32 ret = 0;
1055
1056   v = empathy_account_settings_dup (settings, param);
1057   if (v == NULL)
1058     return 0;
1059
1060   if (g_variant_is_of_type (v, G_VARIANT_TYPE_BYTE))
1061     ret = g_variant_get_byte (v);
1062   else if (g_variant_is_of_type (v, G_VARIANT_TYPE_INT32))
1063     ret = MAX (0, g_variant_get_int32 (v));
1064   else if (g_variant_is_of_type (v, G_VARIANT_TYPE_UINT32))
1065     ret = g_variant_get_uint32 (v);
1066   else if (g_variant_is_of_type (v, G_VARIANT_TYPE_INT64))
1067     ret = CLAMP (g_variant_get_int64 (v), 0, G_MAXUINT32);
1068   else if (g_variant_is_of_type (v, G_VARIANT_TYPE_UINT64))
1069     ret = MIN (g_variant_get_uint64 (v), G_MAXUINT32);
1070   else
1071     {
1072       gchar *tmp;
1073
1074       tmp = g_variant_print (v, TRUE);
1075       DEBUG ("Unsupported type for param '%s': %s'", param, tmp);
1076       g_free (tmp);
1077     }
1078
1079   g_variant_unref (v);
1080   return ret;
1081 }
1082
1083 guint64
1084 empathy_account_settings_get_uint64 (EmpathyAccountSettings *settings,
1085     const gchar *param)
1086 {
1087   GVariant *v;
1088   guint64 ret = 0;
1089
1090   v = empathy_account_settings_dup (settings, param);
1091   if (v == NULL)
1092     return 0;
1093
1094   if (g_variant_is_of_type (v, G_VARIANT_TYPE_BYTE))
1095     ret = g_variant_get_byte (v);
1096   else if (g_variant_is_of_type (v, G_VARIANT_TYPE_INT32))
1097     ret = MAX (0, g_variant_get_int32 (v));
1098   else if (g_variant_is_of_type (v, G_VARIANT_TYPE_UINT32))
1099     ret = g_variant_get_uint32 (v);
1100   else if (g_variant_is_of_type (v, G_VARIANT_TYPE_INT64))
1101     ret = MAX (0, g_variant_get_int64 (v));
1102   else if (g_variant_is_of_type (v, G_VARIANT_TYPE_UINT64))
1103     ret = g_variant_get_uint64 (v);
1104   else
1105     {
1106       gchar *tmp;
1107
1108       tmp = g_variant_print (v, TRUE);
1109       DEBUG ("Unsupported type for param '%s': %s'", param, tmp);
1110       g_free (tmp);
1111     }
1112
1113
1114   g_variant_unref (v);
1115   return ret;
1116 }
1117
1118 gboolean
1119 empathy_account_settings_get_boolean (EmpathyAccountSettings *settings,
1120     const gchar *param)
1121 {
1122   GVariant *v;
1123   gboolean result = FALSE;
1124
1125   v = empathy_account_settings_dup (settings, param);
1126   if (v == NULL)
1127     return result;
1128
1129   if (g_variant_is_of_type (v, G_VARIANT_TYPE_BOOLEAN))
1130     result = g_variant_get_boolean (v);
1131
1132   return result;
1133 }
1134
1135 void
1136 empathy_account_settings_set (EmpathyAccountSettings *settings,
1137     const gchar *param,
1138     GVariant *v)
1139 {
1140   EmpathyAccountSettingsPriv *priv = GET_PRIV (settings);
1141
1142   g_return_if_fail (param != NULL);
1143   g_return_if_fail (v != NULL);
1144
1145   if (!tp_strdiff (param, "password") && priv->supports_sasl &&
1146       g_variant_is_of_type (v, G_VARIANT_TYPE_STRING))
1147     {
1148       g_free (priv->password);
1149       priv->password = g_variant_dup_string (v, NULL);
1150       priv->password_changed = TRUE;
1151     }
1152   else
1153     {
1154       g_hash_table_insert (priv->parameters, g_strdup (param),
1155           g_variant_ref_sink (v));
1156     }
1157
1158   account_settings_remove_from_unset (settings, param);
1159 }
1160
1161 static void
1162 account_settings_display_name_set_cb (GObject *src,
1163     GAsyncResult *res,
1164     gpointer user_data)
1165 {
1166   GError *error = NULL;
1167   TpAccount *account = TP_ACCOUNT (src);
1168   GSimpleAsyncResult *set_result = user_data;
1169
1170   tp_account_set_display_name_finish (account, res, &error);
1171
1172   if (error != NULL)
1173     {
1174       g_simple_async_result_set_from_error (set_result, error);
1175       g_error_free (error);
1176     }
1177
1178   g_simple_async_result_complete (set_result);
1179   g_object_unref (set_result);
1180 }
1181
1182 void
1183 empathy_account_settings_set_display_name_async (
1184   EmpathyAccountSettings *settings,
1185   const gchar *name,
1186   GAsyncReadyCallback callback,
1187   gpointer user_data)
1188 {
1189   EmpathyAccountSettingsPriv *priv = GET_PRIV (settings);
1190   GSimpleAsyncResult *result;
1191
1192   g_return_if_fail (name != NULL);
1193
1194   result = g_simple_async_result_new (G_OBJECT (settings),
1195       callback, user_data, empathy_account_settings_set_display_name_finish);
1196
1197   if (!tp_strdiff (name, priv->display_name))
1198     {
1199       /* Nothing to do */
1200       g_simple_async_result_complete_in_idle (result);
1201       return;
1202     }
1203
1204   if (priv->account == NULL)
1205     {
1206       if (priv->display_name != NULL)
1207         g_free (priv->display_name);
1208
1209       priv->display_name = g_strdup (name);
1210
1211       g_simple_async_result_complete_in_idle (result);
1212
1213       return;
1214     }
1215
1216   tp_account_set_display_name_async (priv->account, name,
1217       account_settings_display_name_set_cb, result);
1218 }
1219
1220 gboolean
1221 empathy_account_settings_set_display_name_finish (
1222   EmpathyAccountSettings *settings,
1223   GAsyncResult *result,
1224   GError **error)
1225 {
1226   if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result),
1227       error))
1228     return FALSE;
1229
1230   g_return_val_if_fail (g_simple_async_result_is_valid (result,
1231     G_OBJECT (settings), empathy_account_settings_set_display_name_finish),
1232       FALSE);
1233
1234   return TRUE;
1235 }
1236
1237 static void
1238 account_settings_icon_name_set_cb (GObject *src,
1239     GAsyncResult *res,
1240     gpointer user_data)
1241 {
1242   GError *error = NULL;
1243   TpAccount *account = TP_ACCOUNT (src);
1244   GSimpleAsyncResult *set_result = user_data;
1245
1246   tp_account_set_icon_name_finish (account, res, &error);
1247
1248   if (error != NULL)
1249     {
1250       g_simple_async_result_set_from_error (set_result, error);
1251       g_error_free (error);
1252     }
1253
1254   g_simple_async_result_complete (set_result);
1255   g_object_unref (set_result);
1256 }
1257
1258 void
1259 empathy_account_settings_set_icon_name_async (
1260   EmpathyAccountSettings *settings,
1261   const gchar *name,
1262   GAsyncReadyCallback callback,
1263   gpointer user_data)
1264 {
1265   EmpathyAccountSettingsPriv *priv = GET_PRIV (settings);
1266   GSimpleAsyncResult *result;
1267
1268   g_return_if_fail (name != NULL);
1269
1270   result = g_simple_async_result_new (G_OBJECT (settings),
1271       callback, user_data, empathy_account_settings_set_icon_name_finish);
1272
1273   if (priv->account == NULL)
1274     {
1275       if (priv->icon_name != NULL)
1276         g_free (priv->icon_name);
1277
1278       priv->icon_name = g_strdup (name);
1279
1280       g_simple_async_result_complete_in_idle (result);
1281
1282       return;
1283     }
1284
1285   tp_account_set_icon_name_async (priv->account, name,
1286       account_settings_icon_name_set_cb, result);
1287 }
1288
1289 gboolean
1290 empathy_account_settings_set_icon_name_finish (
1291   EmpathyAccountSettings *settings,
1292   GAsyncResult *result,
1293   GError **error)
1294 {
1295   if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result),
1296       error))
1297     return FALSE;
1298
1299   g_return_val_if_fail (g_simple_async_result_is_valid (result,
1300     G_OBJECT (settings), empathy_account_settings_set_icon_name_finish),
1301       FALSE);
1302
1303   return TRUE;
1304 }
1305
1306 static void
1307 empathy_account_settings_processed_password (GObject *source,
1308     GAsyncResult *result,
1309     gpointer user_data,
1310     gpointer finish_func)
1311 {
1312   EmpathyAccountSettings *settings = EMPATHY_ACCOUNT_SETTINGS (user_data);
1313   EmpathyAccountSettingsPriv *priv = GET_PRIV (settings);
1314   GSimpleAsyncResult *r;
1315   GError *error = NULL;
1316   gboolean (*func) (TpAccount *source, GAsyncResult *result, GError **error) =
1317     finish_func;
1318
1319   g_free (priv->password_original);
1320   priv->password_original = g_strdup (priv->password);
1321
1322   if (!func (TP_ACCOUNT (source), result, &error))
1323     {
1324       g_simple_async_result_set_from_error (priv->apply_result, error);
1325       g_error_free (error);
1326     }
1327
1328   empathy_account_settings_discard_changes (settings);
1329
1330   r = priv->apply_result;
1331   priv->apply_result = NULL;
1332
1333   g_simple_async_result_complete (r);
1334   g_object_unref (r);
1335 }
1336
1337 static void
1338 empathy_account_settings_set_password_cb (GObject *source,
1339     GAsyncResult *result,
1340     gpointer user_data)
1341 {
1342   empathy_account_settings_processed_password (source, result, user_data,
1343       empathy_keyring_set_account_password_finish);
1344 }
1345
1346 static void
1347 empathy_account_settings_delete_password_cb (GObject *source,
1348     GAsyncResult *result,
1349     gpointer user_data)
1350 {
1351   empathy_account_settings_processed_password (source, result, user_data,
1352       empathy_keyring_delete_account_password_finish);
1353 }
1354
1355 static void
1356 update_account_uri_schemes (EmpathyAccountSettings *self)
1357 {
1358   EmpathyAccountSettingsPriv *priv = GET_PRIV (self);
1359
1360   if (priv->uri_scheme_tel == empathy_account_has_uri_scheme_tel (
1361         priv->account))
1362     return;
1363
1364   tp_account_set_uri_scheme_association_async (priv->account, "tel",
1365       priv->uri_scheme_tel, NULL, NULL);
1366 }
1367
1368 static void
1369 set_service_cb (GObject *source,
1370     GAsyncResult *result,
1371     gpointer user_data)
1372 {
1373   GError *error = NULL;
1374
1375   if (!tp_account_set_service_finish (TP_ACCOUNT (source), result, &error))
1376     {
1377       DEBUG ("Failed to set Account.Service: %s", error->message);
1378       g_error_free (error);
1379     }
1380 }
1381
1382 static void
1383 update_account_service (EmpathyAccountSettings *self)
1384 {
1385   EmpathyAccountSettingsPriv *priv = GET_PRIV (self);
1386
1387   if (!priv->update_service)
1388     return;
1389
1390   tp_account_set_service_async (priv->account,
1391       priv->service != NULL ? priv->service : "", set_service_cb, self);
1392 }
1393
1394 static void
1395 empathy_account_settings_account_updated (GObject *source,
1396     GAsyncResult *result,
1397     gpointer user_data)
1398 {
1399   EmpathyAccountSettings *settings = EMPATHY_ACCOUNT_SETTINGS (user_data);
1400   EmpathyAccountSettingsPriv *priv = GET_PRIV (settings);
1401   GSimpleAsyncResult *r;
1402   GError *error = NULL;
1403   GStrv reconnect_required = NULL;
1404
1405   if (!tp_account_update_parameters_vardict_finish (TP_ACCOUNT (source),
1406           result, &reconnect_required, &error))
1407     {
1408       g_simple_async_result_set_from_error (priv->apply_result, error);
1409       g_error_free (error);
1410       goto out;
1411     }
1412
1413   /* Only set the password in the keyring if the CM supports SASL and
1414    * it's changed. */
1415   if (priv->supports_sasl && priv->password_changed)
1416     {
1417       if (priv->password != NULL)
1418         {
1419           /* FIXME: we shouldn't save the password if we
1420            * can't (MaySaveResponse=False) but we don't have API to check that
1421            * at this point (fdo #35382). */
1422           empathy_keyring_set_account_password_async (priv->account, priv->password,
1423               empathy_account_settings_set_password_cb, settings);
1424         }
1425       else
1426         {
1427           empathy_keyring_delete_account_password_async (priv->account,
1428               empathy_account_settings_delete_password_cb, settings);
1429         }
1430
1431       return;
1432     }
1433
1434   update_account_uri_schemes (settings);
1435   update_account_service (settings);
1436
1437   g_simple_async_result_set_op_res_gboolean (priv->apply_result,
1438       g_strv_length (reconnect_required) > 0);
1439
1440 out:
1441   empathy_account_settings_discard_changes (settings);
1442
1443   r = priv->apply_result;
1444   priv->apply_result = NULL;
1445
1446   g_simple_async_result_complete (r);
1447   g_object_unref (r);
1448   g_strfreev (reconnect_required);
1449 }
1450
1451 static void
1452 empathy_account_settings_created_cb (GObject *source,
1453     GAsyncResult *result,
1454     gpointer user_data)
1455 {
1456   EmpathyAccountSettings *settings = EMPATHY_ACCOUNT_SETTINGS (user_data);
1457   EmpathyAccountSettingsPriv *priv = GET_PRIV (settings);
1458   GError *error = NULL;
1459   GSimpleAsyncResult *r;
1460
1461   priv->account = tp_account_request_create_account_finish (
1462       TP_ACCOUNT_REQUEST (source), result, &error);
1463
1464   if (priv->account == NULL)
1465     {
1466       g_simple_async_result_set_from_error (priv->apply_result, error);
1467     }
1468   else
1469     {
1470       if (priv->supports_sasl && priv->password != NULL)
1471         {
1472           /* Save the password before connecting */
1473           /* FIXME: we shouldn't save the password if we
1474            * can't (MaySaveResponse=False) but we don't have API to check that
1475            * at this point (fdo #35382). */
1476           empathy_keyring_set_account_password_async (priv->account,
1477               priv->password, empathy_account_settings_set_password_cb,
1478               settings);
1479           return;
1480         }
1481
1482       update_account_uri_schemes (settings);
1483
1484       empathy_account_settings_discard_changes (settings);
1485     }
1486
1487   r = priv->apply_result;
1488   priv->apply_result = NULL;
1489
1490   g_simple_async_result_complete (r);
1491   g_object_unref (r);
1492 }
1493
1494 static void
1495 empathy_account_settings_do_create_account (EmpathyAccountSettings *self)
1496 {
1497   EmpathyAccountSettingsPriv *priv = GET_PRIV (self);
1498   TpAccountRequest *account_req;
1499   TpConnectionPresenceType type;
1500   gchar *status;
1501   gchar *message;
1502   EmpathyPresenceManager *presence_mgr;
1503   GHashTableIter iter;
1504   gpointer k, v;
1505
1506   account_req = tp_account_request_new (priv->account_manager, priv->cm_name,
1507       priv->protocol, "New Account");
1508
1509   presence_mgr = empathy_presence_manager_dup_singleton ();
1510   type = empathy_presence_manager_get_requested_presence (presence_mgr, &status,
1511       &message);
1512   g_object_unref (presence_mgr);
1513
1514   if (type != TP_CONNECTION_PRESENCE_TYPE_UNSET)
1515     {
1516       tp_account_request_set_requested_presence (account_req, type,
1517           status, message);
1518     }
1519
1520   tp_account_request_set_icon_name (account_req, priv->icon_name);
1521
1522   tp_account_request_set_display_name (account_req, priv->display_name);
1523
1524   if (priv->service != NULL)
1525     tp_account_request_set_service (account_req, priv->service);
1526
1527   g_hash_table_iter_init (&iter, priv->parameters);
1528   while (g_hash_table_iter_next (&iter, &k, &v))
1529     {
1530       const gchar *key = k;
1531       GVariant *value = v;
1532
1533       tp_account_request_set_parameter (account_req, key, value);
1534     }
1535
1536   tp_account_request_create_account_async (account_req,
1537       empathy_account_settings_created_cb, self);
1538 }
1539
1540 static GVariant *
1541 build_parameters_variant (EmpathyAccountSettings *self)
1542 {
1543   EmpathyAccountSettingsPriv *priv = GET_PRIV (self);
1544   GVariantBuilder *builder;
1545   GHashTableIter iter;
1546   gpointer k, v;
1547
1548   builder = g_variant_builder_new (G_VARIANT_TYPE_VARDICT);
1549
1550   g_hash_table_iter_init (&iter, priv->parameters);
1551   while (g_hash_table_iter_next (&iter, &k, &v))
1552     {
1553       const gchar *key = k;
1554       GVariant *value = v;
1555       GVariant *entry;
1556
1557       entry = g_variant_new_dict_entry (g_variant_new_string (key),
1558           g_variant_new_variant (value));
1559
1560       g_variant_builder_add_value (builder, entry);
1561     }
1562
1563   return g_variant_builder_end (builder);
1564 }
1565
1566 void
1567 empathy_account_settings_apply_async (EmpathyAccountSettings *settings,
1568     GAsyncReadyCallback callback,
1569     gpointer user_data)
1570 {
1571   EmpathyAccountSettingsPriv *priv = GET_PRIV (settings);
1572
1573   if (priv->apply_result != NULL)
1574     {
1575       g_simple_async_report_error_in_idle (G_OBJECT (settings),
1576           callback, user_data,
1577           G_IO_ERROR, G_IO_ERROR_PENDING, "Applying already in progress");
1578       return;
1579     }
1580
1581   priv->apply_result = g_simple_async_result_new (G_OBJECT (settings),
1582       callback, user_data, empathy_account_settings_apply_finish);
1583
1584   /* We'll have to reconnect only if we change none DBus_Property on an
1585    * existing account. */
1586   g_simple_async_result_set_op_res_gboolean (priv->apply_result, FALSE);
1587
1588   if (priv->account == NULL)
1589     {
1590       g_assert (priv->apply_result != NULL && priv->account == NULL);
1591
1592       empathy_account_settings_do_create_account (settings);
1593     }
1594   else
1595     {
1596       tp_account_update_parameters_vardict_async (priv->account,
1597           build_parameters_variant (settings),
1598           (const gchar **) priv->unset_parameters->data,
1599           empathy_account_settings_account_updated, settings);
1600     }
1601 }
1602
1603 gboolean
1604 empathy_account_settings_apply_finish (EmpathyAccountSettings *settings,
1605     GAsyncResult *result,
1606     gboolean *reconnect_required,
1607     GError **error)
1608 {
1609   if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result),
1610       error))
1611     return FALSE;
1612
1613   g_return_val_if_fail (g_simple_async_result_is_valid (result,
1614     G_OBJECT (settings), empathy_account_settings_apply_finish), FALSE);
1615
1616   if (reconnect_required != NULL)
1617     *reconnect_required = g_simple_async_result_get_op_res_gboolean (
1618         G_SIMPLE_ASYNC_RESULT (result));
1619
1620   return TRUE;
1621 }
1622
1623 gboolean
1624 empathy_account_settings_has_account (EmpathyAccountSettings *settings,
1625     TpAccount *account)
1626 {
1627   EmpathyAccountSettingsPriv *priv;
1628   const gchar *account_path;
1629   const gchar *priv_account_path;
1630
1631   g_return_val_if_fail (EMPATHY_IS_ACCOUNT_SETTINGS (settings), FALSE);
1632   g_return_val_if_fail (TP_IS_ACCOUNT (account), FALSE);
1633
1634   priv = GET_PRIV (settings);
1635
1636   if (priv->account == NULL)
1637     return FALSE;
1638
1639   account_path = tp_proxy_get_object_path (TP_PROXY (account));
1640   priv_account_path = tp_proxy_get_object_path (TP_PROXY (priv->account));
1641
1642   return (!tp_strdiff (account_path, priv_account_path));
1643 }
1644
1645 void
1646 empathy_account_settings_set_regex (EmpathyAccountSettings *settings,
1647     const gchar *param,
1648     const gchar *pattern)
1649 {
1650   EmpathyAccountSettingsPriv *priv = GET_PRIV (settings);
1651   GRegex *regex;
1652   GError *error = NULL;
1653
1654   regex = g_regex_new (pattern, 0, 0, &error);
1655   if (regex == NULL)
1656     {
1657       g_warning ("Failed to create reg exp: %s", error->message);
1658       g_error_free (error);
1659       return;
1660     }
1661
1662   g_hash_table_insert (priv->param_regexps, g_strdup (param), regex);
1663 }
1664
1665 gboolean
1666 empathy_account_settings_parameter_is_valid (
1667     EmpathyAccountSettings *settings,
1668     const gchar *param)
1669 {
1670   EmpathyAccountSettingsPriv *priv;
1671   const GRegex *regex;
1672
1673   g_return_val_if_fail (EMPATHY_IS_ACCOUNT_SETTINGS (settings), FALSE);
1674
1675   priv = GET_PRIV (settings);
1676
1677   if (g_list_find_custom (priv->required_params, param, (GCompareFunc) strcmp))
1678     {
1679       /* first, look if it's set in our own parameters */
1680       if (g_hash_table_lookup (priv->parameters, param) != NULL)
1681         goto test_regex;
1682
1683       /* if we did not unset the parameter, look if it's in the account */
1684       if (priv->account != NULL &&
1685           !empathy_account_settings_is_unset (settings, param))
1686         {
1687           const GHashTable *account_params;
1688
1689           account_params = tp_account_get_parameters (priv->account);
1690           if (tp_asv_lookup (account_params, param))
1691             goto test_regex;
1692         }
1693
1694       return FALSE;
1695     }
1696
1697 test_regex:
1698   /* test whether parameter value matches its regex */
1699   regex = g_hash_table_lookup (priv->param_regexps, param);
1700   if (regex)
1701     {
1702       gchar *value;
1703       gboolean match;
1704
1705       value = empathy_account_settings_dup_string (settings, param);
1706       if (value == NULL)
1707         return FALSE;
1708
1709       match = g_regex_match (regex, value, 0, NULL);
1710
1711       g_free (value);
1712       return match;
1713     }
1714
1715   return TRUE;
1716 }
1717
1718 gboolean
1719 empathy_account_settings_is_valid (EmpathyAccountSettings *settings)
1720 {
1721   EmpathyAccountSettingsPriv *priv;
1722   const gchar *param;
1723   GHashTableIter iter;
1724   GList *l;
1725
1726   g_return_val_if_fail (EMPATHY_IS_ACCOUNT_SETTINGS (settings), FALSE);
1727
1728   priv = GET_PRIV (settings);
1729
1730   for (l = priv->required_params; l; l = l->next)
1731     {
1732       if (!empathy_account_settings_parameter_is_valid (settings, l->data))
1733         return FALSE;
1734     }
1735
1736   g_hash_table_iter_init (&iter, priv->param_regexps);
1737   while (g_hash_table_iter_next (&iter, (gpointer *) &param, NULL))
1738     {
1739       if (!empathy_account_settings_parameter_is_valid (settings, param))
1740         return FALSE;
1741     }
1742
1743   return TRUE;
1744 }
1745
1746 TpProtocol *
1747 empathy_account_settings_get_tp_protocol (EmpathyAccountSettings *self)
1748 {
1749   EmpathyAccountSettingsPriv *priv = GET_PRIV (self);
1750
1751   return priv->protocol_obj;
1752 }
1753
1754 gboolean
1755 empathy_account_settings_supports_sasl (EmpathyAccountSettings *self)
1756 {
1757   EmpathyAccountSettingsPriv *priv = GET_PRIV (self);
1758
1759   return priv->supports_sasl;
1760 }
1761
1762 gboolean
1763 empathy_account_settings_param_is_supported (EmpathyAccountSettings *self,
1764     const gchar *param)
1765 {
1766   EmpathyAccountSettingsPriv *priv = GET_PRIV (self);
1767
1768   return tp_protocol_has_param (priv->protocol_obj, param);
1769 }
1770
1771 void
1772 empathy_account_settings_set_uri_scheme_tel (EmpathyAccountSettings *self,
1773     gboolean associate)
1774 {
1775   EmpathyAccountSettingsPriv *priv = GET_PRIV (self);
1776
1777   priv->uri_scheme_tel = associate;
1778 }
1779
1780 gboolean
1781 empathy_account_settings_has_uri_scheme_tel (
1782     EmpathyAccountSettings *self)
1783 {
1784   EmpathyAccountSettingsPriv *priv = GET_PRIV (self);
1785
1786   return priv->uri_scheme_tel;
1787 }