#include "config.h"
-#include <stdio.h>
-#include <stdlib.h>
-
-#include <telepathy-glib/account-manager.h>
-#include <telepathy-glib/util.h>
-#include <telepathy-glib/interfaces.h>
-#include <telepathy-glib/gtypes.h>
-
#include "empathy-account-settings.h"
#include "empathy-connection-managers.h"
#include "empathy-keyring.h"
gchar *service;
gchar *display_name;
gchar *icon_name;
+ gchar *storage_provider;
gboolean display_name_overridden;
gboolean ready;
gboolean supports_sasl;
- gboolean password_changed;
+ gboolean remember_password;
gchar *password;
gchar *password_original;
gboolean password_retrieved;
gboolean password_requested;
- /* Parameter name (gchar *) -> parameter value (GValue) */
+ /* Parameter name (gchar *) -> parameter value (GVariant) */
GHashTable *parameters;
/* Keys are parameter names from the hash above (gchar *).
* Values are regular expresions that should match corresponding parameter
priv->account_manager = tp_account_manager_dup ();
priv->parameters = g_hash_table_new_full (g_str_hash, g_str_equal,
- g_free, (GDestroyNotify) tp_g_value_slice_free);
+ g_free, (GDestroyNotify) g_variant_unref);
priv->param_regexps = g_hash_table_new_full (g_str_hash, g_str_equal,
g_free, (GDestroyNotify) g_regex_unref);
g_free (priv->service);
priv->cm_name =
- g_strdup (tp_account_get_connection_manager (priv->account));
+ g_strdup (tp_account_get_cm_name (priv->account));
priv->protocol =
- g_strdup (tp_account_get_protocol (priv->account));
+ g_strdup (tp_account_get_protocol_name (priv->account));
priv->service =
g_strdup (tp_account_get_service (priv->account));
priv->icon_name = g_strdup
g_free (priv->icon_name);
g_free (priv->password);
g_free (priv->password_original);
+ g_free (priv->storage_provider);
if (priv->required_params != NULL)
{
g_signal_emit (self, signals[PASSWORD_RETRIEVED], 0);
}
-static void
-empathy_account_settings_migrate_password_cb (GObject *source,
- GAsyncResult *result,
- gpointer user_data)
-{
- TpAccount *account = TP_ACCOUNT (source);
- GError *error = NULL;
- EmpathyAccountSettings *self = user_data;
- EmpathyAccountSettingsPriv *priv = GET_PRIV (self);
- GHashTable *empty;
- const gchar *unset[] = { "password", NULL };
-
- if (!empathy_keyring_set_account_password_finish (account, result, &error))
- {
- DEBUG ("Failed to set password: %s", error->message);
- g_clear_error (&error);
- return;
- }
-
- /* Now clear the password MC has stored. */
- empty = tp_asv_new (NULL, NULL);
- tp_account_update_parameters_async (priv->account,
- empty, unset, NULL, NULL);
-
- g_hash_table_remove (priv->parameters, "password");
-
- g_hash_table_unref (empty);
-}
-
-static void
-empathy_account_settings_try_migrating_password (EmpathyAccountSettings *self)
-{
- EmpathyAccountSettingsPriv *priv = GET_PRIV (self);
- const GValue *v;
- const gchar *password;
-
- if (!priv->supports_sasl || empathy_account_settings_get (
- self, "password") == NULL)
- return;
-
- /* mission-control still has our password, although the CM
- * supports SASL. Let's try migrating it. */
-
- DEBUG ("Trying to migrate password parameter from MC to the "
- "keyring ourselves for account %s",
- tp_account_get_path_suffix (priv->account));
-
- v = empathy_account_settings_get (self, "password");
-
- /* I can't imagine why this would fail. */
- if (!G_VALUE_HOLDS_STRING (v))
- return;
-
- password = g_value_get_string (v);
-
- if (EMP_STR_EMPTY (password))
- return;
-
- empathy_keyring_set_account_password_async (priv->account, password,
- empathy_account_settings_migrate_password_cb, self);
-
- /* We don't want to request the password again, we
- * already know it. */
- priv->password_requested = TRUE;
-
- priv->password = g_strdup (password);
- priv->password_original = g_strdup (password);
-}
+static GVariant * empathy_account_settings_dup (
+ EmpathyAccountSettings *settings,
+ const gchar *param);
static void
empathy_account_settings_check_readyness (EmpathyAccountSettings *self)
if (tp_connection_manager_param_is_required (cur))
{
priv->required_params = g_list_append (priv->required_params,
- g_strdup (cur->name));
+ g_strdup (tp_connection_manager_param_get_name (cur)));
}
}
(GDestroyNotify) tp_connection_manager_param_free);
}
- /* NOTE: When removing MC migration code, remove this call, and the
- * function it's calling. That's it. */
- empathy_account_settings_try_migrating_password (self);
-
/* priv->account won't be a proper account if it's the account
* assistant showing this widget. */
if (priv->supports_sasl && !priv->password_requested
}
}
-const GValue *
-empathy_account_settings_get_default (EmpathyAccountSettings *settings,
+GVariant *
+empathy_account_settings_dup_default (EmpathyAccountSettings *settings,
const gchar *param)
{
const TpConnectionManagerParam *p;
p = empathy_account_settings_get_tp_param (settings, param);
-
- if (p == NULL || !(p->flags & TP_CONN_MGR_PARAM_FLAG_HAS_DEFAULT))
+ if (p == NULL)
return NULL;
- return &(p->default_value);
+ return tp_connection_manager_param_dup_default_variant (p);
}
const gchar *
if (p == NULL)
return NULL;
- return p->dbus_signature;
+ return tp_connection_manager_param_get_dbus_signature (p);
}
-const GValue *
-empathy_account_settings_get (EmpathyAccountSettings *settings,
+static GVariant *
+empathy_account_settings_dup (EmpathyAccountSettings *settings,
const gchar *param)
{
EmpathyAccountSettingsPriv *priv = GET_PRIV (settings);
- const GValue *result = NULL;
+ GVariant *result;
/* Lookup the update parameters we set */
- result = tp_asv_lookup (priv->parameters, param);
+ result = g_hash_table_lookup (priv->parameters, param);
if (result != NULL)
- return result;
+ return g_variant_ref (result);
/* If the parameters isn't unset use the accounts setting if any */
if (priv->account != NULL
&& !empathy_account_settings_is_unset (settings, param))
{
- const GHashTable *parameters;
+ GVariant *parameters;
- parameters = tp_account_get_parameters (priv->account);
- result = tp_asv_lookup (parameters, param);
+ parameters = tp_account_dup_parameters_vardict (priv->account);
+ result = g_variant_lookup_value (parameters, param, NULL);
+ g_variant_unref (parameters);
if (result != NULL)
+ /* g_variant_lookup_value() is (transfer full) */
return result;
}
/* fallback to the default */
- return empathy_account_settings_get_default (settings, param);
+ return empathy_account_settings_dup_default (settings, param);
}
void
{
g_free (priv->password);
priv->password = NULL;
- priv->password_changed = TRUE;
return;
}
g_hash_table_remove_all (priv->parameters);
empathy_account_settings_free_unset_parameters (settings);
- priv->password_changed = FALSE;
g_free (priv->password);
priv->password = g_strdup (priv->password_original);
priv->uri_scheme_tel = FALSE;
}
-const gchar *
-empathy_account_settings_get_string (EmpathyAccountSettings *settings,
+gchar *
+empathy_account_settings_dup_string (EmpathyAccountSettings *settings,
const gchar *param)
{
EmpathyAccountSettingsPriv *priv = GET_PRIV (settings);
- const GValue *v;
+ GVariant *v;
+ gchar *result = NULL;
if (!tp_strdiff (param, "password") && priv->supports_sasl)
{
- return priv->password;
+ return g_strdup (priv->password);
}
- v = empathy_account_settings_get (settings, param);
-
- if (v == NULL || !G_VALUE_HOLDS_STRING (v))
+ v = empathy_account_settings_dup (settings, param);
+ if (v == NULL)
return NULL;
- return g_value_get_string (v);
+ if (g_variant_is_of_type (v, G_VARIANT_TYPE_STRING))
+ result = g_variant_dup_string (v, NULL);
+
+ g_variant_unref (v);
+ return result;
}
-const gchar * const *
-empathy_account_settings_get_strv (EmpathyAccountSettings *settings,
+GStrv
+empathy_account_settings_dup_strv (EmpathyAccountSettings *settings,
const gchar *param)
{
- const GValue *v;
+ GVariant *v;
+ GStrv result = NULL;
- v = empathy_account_settings_get (settings, param);
-
- if (v == NULL || !G_VALUE_HOLDS (v, G_TYPE_STRV))
+ v = empathy_account_settings_dup (settings, param);
+ if (v == NULL)
return NULL;
- return g_value_get_boxed (v);
+ if (g_variant_is_of_type (v, G_VARIANT_TYPE_STRING_ARRAY))
+ result = g_variant_dup_strv (v, NULL);
+
+ g_variant_unref (v);
+ return result;
}
gint32
empathy_account_settings_get_int32 (EmpathyAccountSettings *settings,
const gchar *param)
{
- const GValue *v;
+ GVariant *v;
gint32 ret = 0;
- v = empathy_account_settings_get (settings, param);
-
+ v = empathy_account_settings_dup (settings, param);
if (v == NULL)
return 0;
- switch G_VALUE_TYPE (v)
+ if (g_variant_is_of_type (v, G_VARIANT_TYPE_BYTE))
+ ret = g_variant_get_byte (v);
+ else if (g_variant_is_of_type (v, G_VARIANT_TYPE_INT32))
+ ret = g_variant_get_int32 (v);
+ else if (g_variant_is_of_type (v, G_VARIANT_TYPE_UINT32))
+ ret = CLAMP (g_variant_get_uint32 (v), (guint) G_MININT32,
+ G_MAXINT32);
+ else if (g_variant_is_of_type (v, G_VARIANT_TYPE_INT64))
+ ret = CLAMP (g_variant_get_int64 (v), G_MININT32, G_MAXINT32);
+ else if (g_variant_is_of_type (v, G_VARIANT_TYPE_UINT64))
+ ret = CLAMP (g_variant_get_uint64 (v), (guint64) G_MININT32, G_MAXINT32);
+ else
{
- case G_TYPE_UCHAR:
- ret = g_value_get_uchar (v);
- break;
- case G_TYPE_INT:
- ret = g_value_get_int (v);
- break;
- case G_TYPE_UINT:
- ret = CLAMP (g_value_get_uint (v), (guint) G_MININT32,
- G_MAXINT32);
- break;
- case G_TYPE_INT64:
- ret = CLAMP (g_value_get_int64 (v), G_MININT32, G_MAXINT32);
- break;
- case G_TYPE_UINT64:
- ret = CLAMP (g_value_get_uint64 (v), (guint64) G_MININT32,
- G_MAXINT32);
- break;
- default:
- ret = 0;
- break;
+ gchar *tmp;
+
+ tmp = g_variant_print (v, TRUE);
+ DEBUG ("Unsupported type for param '%s': %s'", param, tmp);
+ g_free (tmp);
}
+ g_variant_unref (v);
return ret;
}
empathy_account_settings_get_int64 (EmpathyAccountSettings *settings,
const gchar *param)
{
- const GValue *v;
+ GVariant *v;
gint64 ret = 0;
- v = empathy_account_settings_get (settings, param);
+ v = empathy_account_settings_dup (settings, param);
if (v == NULL)
return 0;
- switch G_VALUE_TYPE (v)
+ if (g_variant_is_of_type (v, G_VARIANT_TYPE_BYTE))
+ ret = g_variant_get_byte (v);
+ else if (g_variant_is_of_type (v, G_VARIANT_TYPE_INT32))
+ ret = g_variant_get_int32 (v);
+ else if (g_variant_is_of_type (v, G_VARIANT_TYPE_UINT32))
+ ret = g_variant_get_uint32 (v);
+ else if (g_variant_is_of_type (v, G_VARIANT_TYPE_INT64))
+ ret = g_variant_get_int64 (v);
+ else if (g_variant_is_of_type (v, G_VARIANT_TYPE_UINT64))
+ ret = CLAMP (g_variant_get_uint64 (v), (guint64) G_MININT64, G_MAXINT64);
+ else
{
- case G_TYPE_UCHAR:
- ret = g_value_get_uchar (v);
- break;
- case G_TYPE_INT:
- ret = g_value_get_int (v);
- break;
- case G_TYPE_UINT:
- ret = g_value_get_uint (v);
- break;
- case G_TYPE_INT64:
- ret = g_value_get_int64 (v);
- break;
- case G_TYPE_UINT64:
- ret = CLAMP (g_value_get_uint64 (v), (guint64) G_MININT64, G_MAXINT64);
- break;
- default:
- ret = 0;
- break;
+ gchar *tmp;
+
+ tmp = g_variant_print (v, TRUE);
+ DEBUG ("Unsupported type for param '%s': %s'", param, tmp);
+ g_free (tmp);
}
+ g_variant_unref (v);
return ret;
}
empathy_account_settings_get_uint32 (EmpathyAccountSettings *settings,
const gchar *param)
{
- const GValue *v;
- guint32 ret;
+ GVariant *v;
+ guint32 ret = 0;
- v = empathy_account_settings_get (settings, param);
+ v = empathy_account_settings_dup (settings, param);
if (v == NULL)
return 0;
- switch G_VALUE_TYPE (v)
+ if (g_variant_is_of_type (v, G_VARIANT_TYPE_BYTE))
+ ret = g_variant_get_byte (v);
+ else if (g_variant_is_of_type (v, G_VARIANT_TYPE_INT32))
+ ret = MAX (0, g_variant_get_int32 (v));
+ else if (g_variant_is_of_type (v, G_VARIANT_TYPE_UINT32))
+ ret = g_variant_get_uint32 (v);
+ else if (g_variant_is_of_type (v, G_VARIANT_TYPE_INT64))
+ ret = CLAMP (g_variant_get_int64 (v), 0, G_MAXUINT32);
+ else if (g_variant_is_of_type (v, G_VARIANT_TYPE_UINT64))
+ ret = MIN (g_variant_get_uint64 (v), G_MAXUINT32);
+ else
{
- case G_TYPE_UCHAR:
- ret = g_value_get_uchar (v);
- break;
- case G_TYPE_INT:
- ret = MAX (0, g_value_get_int (v));
- break;
- case G_TYPE_UINT:
- ret = g_value_get_uint (v);
- break;
- case G_TYPE_INT64:
- ret = CLAMP (g_value_get_int64 (v), 0, G_MAXUINT32);
- break;
- case G_TYPE_UINT64:
- ret = MIN (g_value_get_uint64 (v), G_MAXUINT32);
- break;
- default:
- ret = 0;
- break;
+ gchar *tmp;
+
+ tmp = g_variant_print (v, TRUE);
+ DEBUG ("Unsupported type for param '%s': %s'", param, tmp);
+ g_free (tmp);
}
+ g_variant_unref (v);
return ret;
}
empathy_account_settings_get_uint64 (EmpathyAccountSettings *settings,
const gchar *param)
{
- const GValue *v;
+ GVariant *v;
guint64 ret = 0;
- v = empathy_account_settings_get (settings, param);
-
- if (v == NULL || !G_VALUE_HOLDS_INT (v))
+ v = empathy_account_settings_dup (settings, param);
+ if (v == NULL)
return 0;
- switch G_VALUE_TYPE (v)
+ if (g_variant_is_of_type (v, G_VARIANT_TYPE_BYTE))
+ ret = g_variant_get_byte (v);
+ else if (g_variant_is_of_type (v, G_VARIANT_TYPE_INT32))
+ ret = MAX (0, g_variant_get_int32 (v));
+ else if (g_variant_is_of_type (v, G_VARIANT_TYPE_UINT32))
+ ret = g_variant_get_uint32 (v);
+ else if (g_variant_is_of_type (v, G_VARIANT_TYPE_INT64))
+ ret = MAX (0, g_variant_get_int64 (v));
+ else if (g_variant_is_of_type (v, G_VARIANT_TYPE_UINT64))
+ ret = g_variant_get_uint64 (v);
+ else
{
- case G_TYPE_UCHAR:
- ret = g_value_get_uchar (v);
- break;
- case G_TYPE_INT:
- ret = MAX (0, g_value_get_int (v));
- break;
- case G_TYPE_UINT:
- ret = g_value_get_uint (v);
- break;
- case G_TYPE_INT64:
- ret = MAX (0, g_value_get_int64 (v));
- break;
- case G_TYPE_UINT64:
- ret = g_value_get_uint64 (v);
- break;
- default:
- ret = 0;
- break;
+ gchar *tmp;
+
+ tmp = g_variant_print (v, TRUE);
+ DEBUG ("Unsupported type for param '%s': %s'", param, tmp);
+ g_free (tmp);
}
+
+ g_variant_unref (v);
return ret;
}
empathy_account_settings_get_boolean (EmpathyAccountSettings *settings,
const gchar *param)
{
- const GValue *v;
+ GVariant *v;
+ gboolean result = FALSE;
- v = empathy_account_settings_get (settings, param);
+ v = empathy_account_settings_dup (settings, param);
+ if (v == NULL)
+ return result;
- if (v == NULL || !G_VALUE_HOLDS_BOOLEAN (v))
- return FALSE;
+ if (g_variant_is_of_type (v, G_VARIANT_TYPE_BOOLEAN))
+ result = g_variant_get_boolean (v);
- return g_value_get_boolean (v);
+ return result;
}
void
-empathy_account_settings_set_string (EmpathyAccountSettings *settings,
+empathy_account_settings_set (EmpathyAccountSettings *settings,
const gchar *param,
- const gchar *value)
+ GVariant *v)
{
EmpathyAccountSettingsPriv *priv = GET_PRIV (settings);
g_return_if_fail (param != NULL);
- g_return_if_fail (value != NULL);
+ g_return_if_fail (v != NULL);
- if (!tp_strdiff (param, "password") && priv->supports_sasl)
+ if (!tp_strdiff (param, "password") && priv->supports_sasl &&
+ g_variant_is_of_type (v, G_VARIANT_TYPE_STRING))
{
g_free (priv->password);
- priv->password = g_strdup (value);
- priv->password_changed = TRUE;
+ priv->password = g_variant_dup_string (v, NULL);
}
else
{
- tp_asv_set_string (priv->parameters, g_strdup (param), value);
+ g_hash_table_insert (priv->parameters, g_strdup (param),
+ g_variant_ref_sink (v));
}
account_settings_remove_from_unset (settings, param);
}
-void
-empathy_account_settings_set_strv (EmpathyAccountSettings *settings,
- const gchar *param,
- gchar **value)
-{
- EmpathyAccountSettingsPriv *priv = GET_PRIV (settings);
-
- g_return_if_fail (param != NULL);
- g_return_if_fail (value != NULL);
-
- tp_asv_set_strv (priv->parameters, g_strdup (param), value);
-
- account_settings_remove_from_unset (settings, param);
-}
-
-void
-empathy_account_settings_set_int32 (EmpathyAccountSettings *settings,
- const gchar *param,
- gint32 value)
-{
- EmpathyAccountSettingsPriv *priv = GET_PRIV (settings);
-
- g_return_if_fail (param != NULL);
-
- tp_asv_set_int32 (priv->parameters, g_strdup (param), value);
-
- account_settings_remove_from_unset (settings, param);
-}
-
-void
-empathy_account_settings_set_int64 (EmpathyAccountSettings *settings,
- const gchar *param,
- gint64 value)
-{
- EmpathyAccountSettingsPriv *priv = GET_PRIV (settings);
-
- g_return_if_fail (param != NULL);
-
- tp_asv_set_int64 (priv->parameters, g_strdup (param), value);
-
- account_settings_remove_from_unset (settings, param);
-}
-
-void
-empathy_account_settings_set_uint32 (EmpathyAccountSettings *settings,
- const gchar *param,
- guint32 value)
-{
- EmpathyAccountSettingsPriv *priv = GET_PRIV (settings);
-
- g_return_if_fail (param != NULL);
-
- tp_asv_set_uint32 (priv->parameters, g_strdup (param), value);
-
- account_settings_remove_from_unset (settings, param);
-}
-
-void
-empathy_account_settings_set_uint64 (EmpathyAccountSettings *settings,
- const gchar *param,
- guint64 value)
-{
- EmpathyAccountSettingsPriv *priv = GET_PRIV (settings);
-
- g_return_if_fail (param != NULL);
-
- tp_asv_set_uint64 (priv->parameters, g_strdup (param), value);
-
- account_settings_remove_from_unset (settings, param);
-}
-
-void
-empathy_account_settings_set_boolean (EmpathyAccountSettings *settings,
- const gchar *param,
- gboolean value)
-{
- EmpathyAccountSettingsPriv *priv = GET_PRIV (settings);
-
- g_return_if_fail (param != NULL);
-
- tp_asv_set_boolean (priv->parameters, g_strdup (param), value);
-
- account_settings_remove_from_unset (settings, param);
-}
-
static void
account_settings_display_name_set_cb (GObject *src,
GAsyncResult *res,
GError *error = NULL;
GStrv reconnect_required = NULL;
- if (!tp_account_update_parameters_finish (TP_ACCOUNT (source),
+ if (!tp_account_update_parameters_vardict_finish (TP_ACCOUNT (source),
result, &reconnect_required, &error))
{
g_simple_async_result_set_from_error (priv->apply_result, error);
goto out;
}
- /* Only set the password in the keyring if the CM supports SASL and
- * it's changed. */
- if (priv->supports_sasl && priv->password_changed)
+ update_account_uri_schemes (settings);
+ update_account_service (settings);
+
+ g_simple_async_result_set_op_res_gboolean (priv->apply_result,
+ g_strv_length (reconnect_required) > 0);
+
+ /* Only set the password in the keyring if the CM supports SASL. */
+ if (priv->supports_sasl)
{
if (priv->password != NULL)
{
/* FIXME: we shouldn't save the password if we
* can't (MaySaveResponse=False) but we don't have API to check that
* at this point (fdo #35382). */
- empathy_keyring_set_account_password_async (priv->account, priv->password,
+ empathy_keyring_set_account_password_async (priv->account,
+ priv->password, priv->remember_password,
empathy_account_settings_set_password_cb, settings);
}
else
return;
}
- update_account_uri_schemes (settings);
- update_account_service (settings);
-
- g_simple_async_result_set_op_res_gboolean (priv->apply_result,
- g_strv_length (reconnect_required) > 0);
-
out:
empathy_account_settings_discard_changes (settings);
* can't (MaySaveResponse=False) but we don't have API to check that
* at this point (fdo #35382). */
empathy_keyring_set_account_password_async (priv->account,
- priv->password, empathy_account_settings_set_password_cb,
+ priv->password, priv->remember_password,
+ empathy_account_settings_set_password_cb,
settings);
return;
}
gchar *status;
gchar *message;
EmpathyPresenceManager *presence_mgr;
- GVariant *vardict, *value;
- GVariantIter iter;
- const gchar *key;
+ GHashTableIter iter;
+ gpointer k, v;
account_req = tp_account_request_new (priv->account_manager, priv->cm_name,
priv->protocol, "New Account");
if (priv->service != NULL)
tp_account_request_set_service (account_req, priv->service);
- vardict = empathy_asv_to_vardict (priv->parameters);
-
- g_variant_iter_init (&iter, vardict);
- while (g_variant_iter_loop (&iter, "{sv}", &key, &value))
+ g_hash_table_iter_init (&iter, priv->parameters);
+ while (g_hash_table_iter_next (&iter, &k, &v))
{
+ const gchar *key = k;
+ GVariant *value = v;
+
tp_account_request_set_parameter (account_req, key, value);
}
- g_variant_unref (vardict);
+ if (priv->storage_provider != NULL)
+ {
+ tp_account_request_set_storage_provider (account_req,
+ priv->storage_provider);
+ }
tp_account_request_create_account_async (account_req,
empathy_account_settings_created_cb, self);
}
+static GVariant *
+build_parameters_variant (EmpathyAccountSettings *self)
+{
+ EmpathyAccountSettingsPriv *priv = GET_PRIV (self);
+ GVariantBuilder *builder;
+ GHashTableIter iter;
+ gpointer k, v;
+
+ builder = g_variant_builder_new (G_VARIANT_TYPE_VARDICT);
+
+ g_hash_table_iter_init (&iter, priv->parameters);
+ while (g_hash_table_iter_next (&iter, &k, &v))
+ {
+ const gchar *key = k;
+ GVariant *value = v;
+ GVariant *entry;
+
+ entry = g_variant_new_dict_entry (g_variant_new_string (key),
+ g_variant_new_variant (value));
+
+ g_variant_builder_add_value (builder, entry);
+ }
+
+ return g_variant_builder_end (builder);
+}
+
void
empathy_account_settings_apply_async (EmpathyAccountSettings *settings,
GAsyncReadyCallback callback,
}
else
{
- tp_account_update_parameters_async (priv->account,
- priv->parameters, (const gchar **)priv->unset_parameters->data,
+ tp_account_update_parameters_vardict_async (priv->account,
+ build_parameters_variant (settings),
+ (const gchar **) priv->unset_parameters->data,
empathy_account_settings_account_updated, settings);
}
}
{
EmpathyAccountSettingsPriv *priv;
const GRegex *regex;
- const gchar *value;
g_return_val_if_fail (EMPATHY_IS_ACCOUNT_SETTINGS (settings), FALSE);
if (g_list_find_custom (priv->required_params, param, (GCompareFunc) strcmp))
{
/* first, look if it's set in our own parameters */
- if (tp_asv_lookup (priv->parameters, param))
+ if (g_hash_table_lookup (priv->parameters, param) != NULL)
goto test_regex;
/* if we did not unset the parameter, look if it's in the account */
regex = g_hash_table_lookup (priv->param_regexps, param);
if (regex)
{
- value = empathy_account_settings_get_string (settings, param);
- if (value != NULL && !g_regex_match (regex, value, 0, NULL))
+ gchar *value;
+ gboolean match;
+
+ value = empathy_account_settings_dup_string (settings, param);
+ if (value == NULL)
return FALSE;
+
+ match = g_regex_match (regex, value, 0, NULL);
+
+ g_free (value);
+ return match;
}
return TRUE;
return priv->uri_scheme_tel;
}
+
+void
+empathy_account_settings_set_storage_provider (EmpathyAccountSettings *self,
+ const gchar *storage)
+{
+ EmpathyAccountSettingsPriv *priv = GET_PRIV (self);
+
+ g_free (priv->storage_provider);
+ priv->storage_provider = g_strdup (storage);
+}
+
+void
+empathy_account_settings_set_remember_password (EmpathyAccountSettings *self,
+ gboolean remember)
+{
+ EmpathyAccountSettingsPriv *priv = GET_PRIV (self);
+
+ priv->remember_password = remember;
+}