X-Git-Url: http://git.maemo.org/git/?a=blobdiff_plain;f=src%2Fmodest-account-mgr.c;h=56e29ab752a99febae815ef7ade09f1dd93ce57d;hb=45b40150bbd0df379ff829f8cb8e4be364ae68d3;hp=624bff066d9de0d971dd0569ed82979a73d29756;hpb=362784ce756b3f0e31cd451d9ac5e69b909d4053;p=modest diff --git a/src/modest-account-mgr.c b/src/modest-account-mgr.c index 624bff0..56e29ab 100644 --- a/src/modest-account-mgr.c +++ b/src/modest-account-mgr.c @@ -52,94 +52,174 @@ enum { static GObjectClass *parent_class = NULL; static guint signals[LAST_SIGNAL] = {0}; -/* /\* We signal key changes in batches, every X seconds: *\/ */ -/* static gboolean */ -/* on_timeout_notify_changes (gpointer data) */ -/* { */ -/* ModestAccountMgr *self = MODEST_ACCOUNT_MGR (data); */ -/* ModestAccountMgrPrivate *priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self); */ +/* is the account already in the queue? */ +static gboolean +in_change_queue (GSList *change_queue, const gchar *account) +{ + GSList *cursor = change_queue; + while (cursor) { + const gchar *acc = cursor->data; + if (acc && strcmp (acc, account) == 0) + return TRUE; + cursor = g_slist_next (cursor); + } + return FALSE; +} + +static GSList* +add_to_change_queue (GSList *change_queue, const gchar *account_name) +{ + g_return_val_if_fail (account_name, change_queue); + return g_slist_prepend (change_queue, g_strdup (account_name)); +} + + +/* we don't need to track specific accounts, as in our UI case + * it's impossible to change two accounts within .5 seconds. + * still, we might want to allow that later, and then this func + * will come in handy */ +#if 0 +static GSList* +remove_from_queue (GSList *change_queue, const gchar *account) +{ + GSList *cursor = change_queue; + while (cursor) { + const gchar *acc = cursor->data; + if (acc && strcmp (acc, account) == 0) { + g_free (acc); + return g_slist_delete_link (change_queue, cursor); + } + cursor = g_slist_next (cursor); + } + return change_queue; +} +#endif + +static gboolean +on_timeout_notify_changes (gpointer data) +{ + ModestAccountMgr *self = MODEST_ACCOUNT_MGR (data); + ModestAccountMgrPrivate *priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self); -/* /\* TODO: Also store the account names, and notify one list for each account, */ -/* * if anything uses the account names. *\/ */ + GSList *cursor = priv->change_queue; + while (cursor) { + const gchar *account = cursor->data; + if (account) + g_signal_emit (G_OBJECT(self), signals[ACCOUNT_CHANGED_SIGNAL], 0, + account); + cursor = g_slist_next (cursor); + } -/* if (priv->changed_conf_keys) { */ -/* gchar *default_account = */ -/* modest_account_mgr_get_default_account (self); */ - -/* /\* printf ("DEBUG: %s: priv->changed_conf_key length=%d\n", */ -/* __FUNCTION__, g_slist_length (priv->changed_conf_keys)); *\/ */ -/* g_signal_emit (G_OBJECT(self), signals[ACCOUNT_CHANGED_SIGNAL], 0, */ -/* default_account, priv->changed_conf_keys, FALSE); */ - -/* g_free (default_account); */ - -/* g_slist_foreach (priv->changed_conf_keys, (GFunc) g_free, NULL); */ -/* g_slist_free (priv->changed_conf_keys); */ -/* priv->changed_conf_keys = NULL; */ -/* } */ + /* free our queue */ + g_slist_foreach (priv->change_queue, (GFunc)g_free, NULL); + g_slist_free (priv->change_queue); + priv->change_queue = NULL; + priv->timeout = 0; /* hmmm */ -/* return TRUE; /\* Call this again later. *\/ */ -/* } */ - -/* static void */ -/* on_key_change (ModestConf *conf, const gchar *key, ModestConfEvent event, gpointer user_data) */ -/* { */ -/* ModestAccountMgr *self = MODEST_ACCOUNT_MGR (user_data); */ -/* ModestAccountMgrPrivate *priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self); */ -/* gboolean is_account_key; */ -/* gboolean is_server_account; */ -/* gchar* account = NULL; */ - -/* /\* there is only one not-really-account key which will still emit */ -/* * a signal: a change in MODEST_CONF_DEFAULT_ACCOUNT *\/ */ -/* if (key && strcmp (key, MODEST_CONF_DEFAULT_ACCOUNT) == 0) { */ -/* /\* Get the default account instead. *\/ */ + return FALSE; /* don't call me again */ +} + + +/* little hack to retrieve the account name from a server account name, + * by relying on the convention for that. Note: this changes the + * string in-place + * + * server accounts look like fooID_transport or fooID_store + * FIXME: make the suffixes more explicit in the account setup + */ +static void +get_account_name_from_server_account (gchar *server_account_name) +{ + static const gchar *t = "ID_transport"; + static const gchar *s = "ID_store"; + const guint len_t = strlen (t); + const guint len_s = strlen (s); + + guint len_a = strlen (server_account_name); -/* /\* Store the key for later notification in our timeout callback. */ -/* * Notifying for every key change would cause unnecessary work: *\/ */ -/* priv->changed_conf_keys = g_slist_append (priv->changed_conf_keys, */ -/* (gpointer) g_strdup (key)); */ -/* } */ + if (g_str_has_suffix (server_account_name, t)) + server_account_name [len_a - len_t] = '\0'; + else if (g_str_has_suffix (server_account_name, s)) + server_account_name [len_a - len_s] = '\0'; +} + + + +static void +on_key_change (ModestConf *conf, const gchar *key, ModestConfEvent event, + ModestConfNotificationId id, gpointer user_data) +{ + ModestAccountMgr *self = MODEST_ACCOUNT_MGR (user_data); + ModestAccountMgrPrivate *priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self); + + gboolean is_account_key; + gboolean is_server_account; + gchar* account_name = NULL; + + /* there is only one not-really-account key which will still emit + * a signal: a change in MODEST_CONF_DEFAULT_ACCOUNT */ + if (key && strcmp (key, MODEST_CONF_DEFAULT_ACCOUNT) == 0) { + /* Get the default account instead. */ + gchar *default_account = modest_account_mgr_get_default_account (self); + if (!default_account) { + g_warning ("BUG: cannot find default account"); + return; + } else { + g_signal_emit (G_OBJECT(self), signals[ACCOUNT_CHANGED_SIGNAL], 0, + default_account); + g_free(default_account); + return; + } + } -/* is_account_key = FALSE; */ -/* is_server_account = FALSE; */ -/* account = _modest_account_mgr_account_from_key (key, &is_account_key, */ -/* &is_server_account); */ - -/* /\* if this is not an account-related key change, ignore *\/ */ -/* if (!account) */ -/* return; */ - -/* /\* account was removed. Do not emit an account removed signal */ -/* because it was already being done in the remove_account */ -/* method. Do not notify also the removal of the server */ -/* account keys for the same reason *\/ */ -/* if ((is_account_key || is_server_account) && */ -/* event == MODEST_CONF_EVENT_KEY_UNSET) { */ -/* g_free (account); */ -/* return; */ -/* } */ - -/* /\* is this account enabled? *\/ */ -/* gboolean enabled = FALSE; */ -/* if (is_server_account) */ -/* enabled = TRUE; */ -/* else */ -/* enabled = modest_account_mgr_get_enabled (self, account); */ - -/* /\* Notify is server account was changed, default account was changed */ -/* * or when enabled/disabled changes: */ -/* *\/ */ -/* if (enabled || */ -/* g_str_has_suffix (key, MODEST_ACCOUNT_ENABLED) || */ -/* strcmp (key, MODEST_CONF_DEFAULT_ACCOUNT) == 0) { */ -/* /\* Store the key for later notification in our timeout callback. */ -/* * Notifying for every key change would cause unnecessary work: *\/ */ -/* priv->changed_conf_keys = g_slist_append (NULL, */ -/* (gpointer) g_strdup (key)); */ -/* } */ -/* g_free (account); */ -/* } */ + is_account_key = FALSE; + is_server_account = FALSE; + account_name = _modest_account_mgr_account_from_key (key, &is_account_key, + &is_server_account); + + /* if this is not an account-related key change, ignore */ + if (!account_name) + return; + + /* ignore server account changes */ + if (is_server_account) + /* change in place: retrieve the parent account name */ + get_account_name_from_server_account (account_name); + + /* account was removed. Do not emit an account removed signal + because it was already being done in the remove_account + method. Do not notify also the removal of the server + account keys for the same reason */ + if ((is_account_key || is_server_account) && + event == MODEST_CONF_EVENT_KEY_UNSET) { + g_free (account_name); + return; + } + + /* is this account enabled? */ + gboolean enabled = FALSE; + if (is_server_account) + enabled = TRUE; + else + enabled = modest_account_mgr_get_enabled (self, account_name); + + /* Notify is server account was changed, default account was changed + * or when enabled/disabled changes: + */ + if (!is_server_account) + if (enabled || g_str_has_suffix (key, MODEST_ACCOUNT_ENABLED) || + strcmp (key, MODEST_CONF_DEFAULT_ACCOUNT) == 0) { + if (!in_change_queue (priv->change_queue, account_name)) { + priv->change_queue = add_to_change_queue (priv->change_queue, + account_name); + /* hmm, small race when this object is destroyed within + * 500ms of the last change, and there are multiple timeouts... */ + priv->timeout = g_timeout_add (500, (GSourceFunc)on_timeout_notify_changes, + self); + } + } + g_free (account_name); +} GType @@ -199,8 +279,8 @@ modest_account_mgr_base_init (gpointer g_class) G_SIGNAL_RUN_FIRST, G_STRUCT_OFFSET(ModestAccountMgrClass,account_changed), NULL, NULL, - modest_marshal_VOID__STRING_POINTER_BOOLEAN, - G_TYPE_NONE, 3, G_TYPE_STRING, G_TYPE_POINTER, G_TYPE_BOOLEAN); + g_cclosure_marshal_VOID__STRING, + G_TYPE_NONE, 1, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN); signals[ACCOUNT_BUSY_SIGNAL] = g_signal_new ("account_busy_changed", @@ -235,9 +315,11 @@ modest_account_mgr_init (ModestAccountMgr * obj) ModestAccountMgrPrivate *priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (obj); - priv->modest_conf = NULL; + priv->modest_conf = NULL; priv->busy_accounts = NULL; - + priv->change_queue = NULL; + priv->timeout = 0; + priv->notification_id_accounts = g_hash_table_new_full (g_int_hash, g_int_equal, g_free, g_free); } @@ -263,14 +345,11 @@ modest_account_mgr_finalize (GObject * obj) g_object_unref (G_OBJECT(priv->modest_conf)); priv->modest_conf = NULL; } - -/* if (priv->timeout) */ -/* g_source_remove (priv->timeout); */ - -/* if (priv->changed_conf_keys) { */ -/* g_slist_foreach (priv->changed_conf_keys, (GFunc) g_free, NULL); */ -/* g_slist_free (priv->changed_conf_keys); */ -/* } */ + + if (priv->timeout) + g_source_remove (priv->timeout); + priv->timeout = 0; + G_OBJECT_CLASS(parent_class)->finalize (obj); } @@ -290,10 +369,10 @@ modest_account_mgr_new (ModestConf *conf) g_object_ref (G_OBJECT(conf)); priv->modest_conf = conf; -/* priv->key_changed_handler_uid = */ -/* g_signal_connect (G_OBJECT (conf), "key_changed", */ -/* G_CALLBACK (on_key_change), */ -/* obj); */ + priv->key_changed_handler_uid = + g_signal_connect (G_OBJECT (conf), "key_changed", + G_CALLBACK (on_key_change), + obj); return MODEST_ACCOUNT_MGR (obj); } @@ -1018,7 +1097,7 @@ modest_account_mgr_set_list (ModestAccountMgr *self, } gboolean -modest_account_mgr_account_exists (ModestAccountMgr * self, const gchar * name, +modest_account_mgr_account_exists (ModestAccountMgr * self, const gchar* name, gboolean server_account) { ModestAccountMgrPrivate *priv; @@ -1027,7 +1106,7 @@ modest_account_mgr_account_exists (ModestAccountMgr * self, const gchar * name, gboolean retval; GError *err = NULL; - g_return_val_if_fail (MODEST_IS_ACCOUNT_MGR(self), FALSE); + g_return_val_if_fail (self, FALSE); g_return_val_if_fail (name, FALSE); keyname = _modest_account_mgr_get_account_keyname (name, NULL, server_account); @@ -1165,20 +1244,45 @@ _modest_account_mgr_account_from_key (const gchar *key, gboolean *is_account_key + +/* optimization: only with non-alphanum chars, escaping is needed */ +inline static gboolean +is_alphanum (const gchar* str) +{ + const gchar *cursor; + for (cursor = str; cursor && *cursor; ++cursor) { + const char c = *cursor; + /* we cannot trust isalnum(3), because it might consider locales */ + /* numbers ALPHA alpha */ + if (!((c>=48 && c<=57)||(c>=65 && c<=90)||(c>=97 && c<=122))) + return FALSE; + } + return TRUE; +} + + /* must be freed by caller */ gchar * _modest_account_mgr_get_account_keyname (const gchar *account_name, const gchar * name, gboolean server_account) { - gchar *retval = NULL; - + gchar *retval = NULL; gchar *namespace = server_account ? MODEST_SERVER_ACCOUNT_NAMESPACE : MODEST_ACCOUNT_NAMESPACE; + gchar *escaped_account_name, *escaped_name; if (!account_name) return g_strdup (namespace); - /* Always escape the conf keys, so that it is acceptable to gconf: */ - gchar *escaped_account_name = account_name ? modest_conf_key_escape (account_name) : NULL; - gchar *escaped_name = name ? modest_conf_key_escape (name) : NULL; + /* optimization: only escape names when need to be escaped */ + if (is_alphanum (account_name)) + escaped_account_name = (gchar*)account_name; + else + escaped_account_name = modest_conf_key_escape (account_name); + + if (is_alphanum (name)) + escaped_name = (gchar*)name; + else + escaped_name = modest_conf_key_escape (name); + ////////////////////////////////////////////////////////////// if (escaped_account_name && escaped_name) retval = g_strconcat (namespace, "/", escaped_account_name, "/", escaped_name, NULL); @@ -1192,9 +1296,12 @@ _modest_account_mgr_get_account_keyname (const gchar *account_name, const gchar retval = NULL; } - g_free (escaped_name); - g_free (escaped_account_name); - + /* g_free is only needed if we actually allocated anything */ + if (name != escaped_name) + g_free (escaped_name); + if (account_name != escaped_account_name) + g_free (escaped_account_name); + return retval; } @@ -1222,7 +1329,7 @@ compare_account_name(gconstpointer a, gconstpointer b) void modest_account_mgr_set_account_busy(ModestAccountMgr* self, const gchar* account_name, - gboolean busy) + gboolean busy) { ModestAccountMgrPrivate* priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self); if (busy)