1 /* Copyright (c) 2006, Nokia Corporation
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions are
8 * * Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * * Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * * Neither the name of the Nokia Corporation nor the names of its
14 * contributors may be used to endorse or promote products derived from
15 * this software without specific prior written permission.
17 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
18 * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
19 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
20 * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
21 * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
22 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
23 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
24 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
25 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
26 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
27 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31 #include <modest-marshal.h>
32 #include <modest-runtime.h>
33 #include <modest-account-mgr.h>
34 #include <modest-account-mgr-priv.h>
35 #include <modest-account-mgr-helpers.h>
36 #include <modest-platform.h>
38 /* 'private'/'protected' functions */
39 static void modest_account_mgr_class_init (ModestAccountMgrClass * klass);
40 static void modest_account_mgr_init (ModestAccountMgr * obj);
41 static void modest_account_mgr_finalize (GObject * obj);
42 static void modest_account_mgr_base_init (gpointer g_class);
44 static const gchar *_modest_account_mgr_get_account_keyname_cached (ModestAccountMgrPrivate *priv,
45 const gchar* account_name,
49 static gboolean modest_account_mgr_unset_default_account (ModestAccountMgr *self);
53 ACCOUNT_INSERTED_SIGNAL,
54 ACCOUNT_CHANGED_SIGNAL,
55 ACCOUNT_REMOVED_SIGNAL,
57 DEFAULT_ACCOUNT_CHANGED_SIGNAL,
58 DISPLAY_NAME_CHANGED_SIGNAL,
59 ACCOUNT_UPDATED_SIGNAL,
64 static GObjectClass *parent_class = NULL;
65 static guint signals[LAST_SIGNAL] = {0};
68 modest_account_mgr_get_type (void)
70 static GType my_type = 0;
73 static const GTypeInfo my_info = {
74 sizeof (ModestAccountMgrClass),
75 modest_account_mgr_base_init, /* base init */
76 NULL, /* base finalize */
77 (GClassInitFunc) modest_account_mgr_class_init,
78 NULL, /* class finalize */
79 NULL, /* class data */
80 sizeof (ModestAccountMgr),
82 (GInstanceInitFunc) modest_account_mgr_init,
86 my_type = g_type_register_static (G_TYPE_OBJECT,
94 modest_account_mgr_base_init (gpointer g_class)
96 static gboolean modest_account_mgr_initialized = FALSE;
98 if (!modest_account_mgr_initialized) {
99 /* signal definitions */
100 signals[ACCOUNT_INSERTED_SIGNAL] =
101 g_signal_new ("account_inserted",
102 MODEST_TYPE_ACCOUNT_MGR,
104 G_STRUCT_OFFSET(ModestAccountMgrClass, account_inserted),
106 g_cclosure_marshal_VOID__STRING,
107 G_TYPE_NONE, 1, G_TYPE_STRING);
109 signals[ACCOUNT_REMOVED_SIGNAL] =
110 g_signal_new ("account_removed",
111 MODEST_TYPE_ACCOUNT_MGR,
113 G_STRUCT_OFFSET(ModestAccountMgrClass, account_removed),
115 g_cclosure_marshal_VOID__STRING,
116 G_TYPE_NONE, 1, G_TYPE_STRING);
118 signals[ACCOUNT_CHANGED_SIGNAL] =
119 g_signal_new ("account_changed",
120 MODEST_TYPE_ACCOUNT_MGR,
122 G_STRUCT_OFFSET(ModestAccountMgrClass, account_changed),
124 modest_marshal_VOID__STRING_INT,
125 G_TYPE_NONE, 2, G_TYPE_STRING, G_TYPE_INT);
127 signals[ACCOUNT_BUSY_SIGNAL] =
128 g_signal_new ("account_busy_changed",
129 MODEST_TYPE_ACCOUNT_MGR,
131 G_STRUCT_OFFSET(ModestAccountMgrClass, account_busy_changed),
133 modest_marshal_VOID__STRING_BOOLEAN,
134 G_TYPE_NONE, 2, G_TYPE_STRING, G_TYPE_BOOLEAN);
136 signals[DEFAULT_ACCOUNT_CHANGED_SIGNAL] =
137 g_signal_new ("default_account_changed",
138 MODEST_TYPE_ACCOUNT_MGR,
140 G_STRUCT_OFFSET(ModestAccountMgrClass, default_account_changed),
142 g_cclosure_marshal_VOID__VOID,
145 signals[DISPLAY_NAME_CHANGED_SIGNAL] =
146 g_signal_new ("display_name_changed",
147 MODEST_TYPE_ACCOUNT_MGR,
149 G_STRUCT_OFFSET(ModestAccountMgrClass, display_name_changed),
151 g_cclosure_marshal_VOID__STRING,
152 G_TYPE_NONE, 1, G_TYPE_STRING);
154 signals[ACCOUNT_UPDATED_SIGNAL] =
155 g_signal_new ("account_updated",
156 MODEST_TYPE_ACCOUNT_MGR,
158 G_STRUCT_OFFSET(ModestAccountMgrClass, account_updated),
160 g_cclosure_marshal_VOID__STRING,
161 G_TYPE_NONE, 1, G_TYPE_STRING);
164 modest_account_mgr_initialized = TRUE;
169 modest_account_mgr_class_init (ModestAccountMgrClass * klass)
171 GObjectClass *gobject_class;
172 gobject_class = (GObjectClass *) klass;
174 parent_class = g_type_class_peek_parent (klass);
175 gobject_class->finalize = modest_account_mgr_finalize;
177 g_type_class_add_private (gobject_class,
178 sizeof (ModestAccountMgrPrivate));
183 modest_account_mgr_init (ModestAccountMgr * obj)
185 ModestAccountMgrPrivate *priv =
186 MODEST_ACCOUNT_MGR_GET_PRIVATE (obj);
188 priv->modest_conf = NULL;
189 priv->busy_accounts = NULL;
192 priv->notification_id_accounts = g_hash_table_new_full (g_int_hash, g_int_equal, g_free, g_free);
194 /* we maintain hashes for the modest-conf keys we build from account name
195 * + key. many seem to be used often, and generating them showed up high
197 /* both hashes are hashes to hashes;
198 * account-key => keyname ==> account-key-name
200 priv->server_account_key_hash = g_hash_table_new_full (g_str_hash,
203 (GDestroyNotify)g_hash_table_destroy);
204 priv->account_key_hash = g_hash_table_new_full (g_str_hash,
207 (GDestroyNotify)g_hash_table_destroy);
209 /* FALSE means: status is unknown */
210 priv->has_accounts = FALSE;
211 priv->has_enabled_accounts = FALSE;
215 modest_account_mgr_finalize (GObject * obj)
217 ModestAccountMgrPrivate *priv =
218 MODEST_ACCOUNT_MGR_GET_PRIVATE (obj);
220 if (priv->notification_id_accounts) {
221 /* TODO: forget dirs */
223 g_hash_table_destroy (priv->notification_id_accounts);
226 if (priv->modest_conf) {
227 g_object_unref (G_OBJECT(priv->modest_conf));
228 priv->modest_conf = NULL;
232 g_source_remove (priv->timeout);
235 if (priv->server_account_key_hash) {
236 g_hash_table_destroy (priv->server_account_key_hash);
237 priv->server_account_key_hash = NULL;
240 if (priv->account_key_hash) {
241 g_hash_table_destroy (priv->account_key_hash);
242 priv->account_key_hash = NULL;
245 G_OBJECT_CLASS(parent_class)->finalize (obj);
250 modest_account_mgr_new (ModestConf *conf)
253 ModestAccountMgrPrivate *priv;
255 g_return_val_if_fail (conf, NULL);
257 obj = G_OBJECT (g_object_new (MODEST_TYPE_ACCOUNT_MGR, NULL));
258 priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (obj);
260 g_object_ref (G_OBJECT(conf));
261 priv->modest_conf = conf;
263 return MODEST_ACCOUNT_MGR (obj);
268 null_means_empty (const gchar * str)
270 return str ? str : "";
274 modest_account_mgr_add_account_from_settings (ModestAccountMgr *self,
275 ModestAccountSettings *settings)
277 ModestAccountMgrPrivate *priv;
278 const gchar* display_name;
279 gchar *account_name_start, *account_name;
280 gchar *store_name_start, *store_name;
281 gchar *transport_name_start, *transport_name;
282 gchar *default_account;
283 ModestServerAccountSettings *store_settings, *transport_settings;
285 g_return_val_if_fail (MODEST_IS_ACCOUNT_MGR (self), FALSE);
286 g_return_val_if_fail (MODEST_IS_ACCOUNT_SETTINGS (settings), FALSE);
288 priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
289 display_name = modest_account_settings_get_display_name (settings);
291 /* We should have checked for this already, and changed that name accordingly,
292 * but let's check again just in case */
294 modest_account_mgr_account_with_display_name_exists (self, display_name)) {
298 /* Increment the non-user visible name if necessary,
299 * based on the display name: */
300 account_name_start = g_strdup_printf ("%sID", display_name);
301 account_name = modest_account_mgr_get_unused_account_name (self,
302 account_name_start, FALSE /* not a server account */);
303 g_free (account_name_start);
305 /* Add a (incoming) server account, to be used by the account: */
306 store_name_start = g_strconcat (account_name, "_store", NULL);
307 store_name = modest_account_mgr_get_unused_account_name (self,
308 store_name_start, TRUE /* server account */);
309 g_free (store_name_start);
311 /* Add a (outgoing) server account to be used by the account: */
312 transport_name_start = g_strconcat (account_name, "_transport", NULL);
313 transport_name = modest_account_mgr_get_unused_account_name (self,
314 transport_name_start, TRUE /* server account */);
315 g_free (transport_name_start);
317 modest_account_settings_set_account_name (settings, account_name);
318 store_settings = modest_account_settings_get_store_settings (settings);
319 modest_server_account_settings_set_account_name (store_settings, store_name);
320 transport_settings = modest_account_settings_get_transport_settings (settings);
321 modest_server_account_settings_set_account_name (transport_settings, transport_name);
322 g_object_unref (store_settings);
323 g_object_unref (transport_settings);
325 /* Create the account, which will contain the two "server accounts": */
326 modest_account_mgr_save_account_settings (self, settings);
328 g_free (transport_name);
331 /* There must be at least one account now: */
332 /* Note, when this fails is is caused by a Maemo gconf bug that has been
333 * fixed in versions after 3.1. */
334 if(!modest_account_mgr_has_accounts (self, FALSE))
335 g_warning ("modest_account_mgr_account_names() returned NULL after adding an account.");
337 /* Notify the observers */
338 g_signal_emit (self, signals[ACCOUNT_INSERTED_SIGNAL], 0, account_name);
340 /* if no default account has been defined yet, do so now */
341 default_account = modest_account_mgr_get_default_account (self);
342 if (!default_account) {
343 modest_account_mgr_set_default_account (self, account_name);
344 modest_account_settings_set_is_default (settings, TRUE);
346 g_free (default_account);
347 g_free (account_name);
349 /* (re)set the automatic account update */
350 modest_platform_set_update_interval
351 (modest_conf_get_int (priv->modest_conf, MODEST_CONF_UPDATE_INTERVAL, NULL));
358 modest_account_mgr_add_account (ModestAccountMgr *self,
360 const gchar *display_name,
361 const gchar *user_fullname,
362 const gchar *user_email,
363 ModestAccountRetrieveType retrieve_type,
364 const gchar *store_account,
365 const gchar *transport_account,
368 ModestAccountMgrPrivate *priv;
371 gchar *default_account;
374 g_return_val_if_fail (MODEST_IS_ACCOUNT_MGR(self), FALSE);
375 g_return_val_if_fail (name, FALSE);
376 g_return_val_if_fail (strchr(name, '/') == NULL, FALSE);
378 priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
381 * we create the account by adding an account 'dir', with the name <name>,
382 * and in that the 'display_name' string key
384 key = _modest_account_mgr_get_account_keyname_cached (priv, name, MODEST_ACCOUNT_DISPLAY_NAME,
386 if (modest_account_mgr_account_exists (self, key, FALSE)) {
387 g_printerr ("modest: account already exists\n");
391 ok = modest_conf_set_string (priv->modest_conf, key, name, &err);
393 g_printerr ("modest: cannot set display name\n");
395 g_printerr ("modest: Error adding account conf: %s\n", err->message);
402 key = _modest_account_mgr_get_account_keyname_cached (priv, name, MODEST_ACCOUNT_STORE_ACCOUNT,
404 ok = modest_conf_set_string (priv->modest_conf, key, store_account, &err);
406 g_printerr ("modest: failed to set store account '%s'\n",
409 g_printerr ("modest: Error adding store account conf: %s\n", err->message);
416 if (transport_account) {
417 key = _modest_account_mgr_get_account_keyname_cached (priv, name,
418 MODEST_ACCOUNT_TRANSPORT_ACCOUNT,
420 ok = modest_conf_set_string (priv->modest_conf, key, transport_account, &err);
422 g_printerr ("modest: failed to set transport account '%s'\n",
425 g_printerr ("modest: Error adding transport account conf: %s\n", err->message);
432 /* Make sure that leave-messages-on-server is enabled by default,
433 * as per the UI spec, though it is only meaningful for accounts using POP.
434 * (possibly this gconf key should be under the server account): */
435 modest_account_mgr_set_bool (self, name, MODEST_ACCOUNT_LEAVE_ON_SERVER, TRUE, FALSE);
436 modest_account_mgr_set_bool (self, name, MODEST_ACCOUNT_ENABLED, enabled,FALSE);
438 /* Fill other data */
439 modest_account_mgr_set_string (self, name,
440 MODEST_ACCOUNT_DISPLAY_NAME,
441 display_name, FALSE);
442 modest_account_mgr_set_string (self, name,
443 MODEST_ACCOUNT_FULLNAME,
444 user_fullname, FALSE);
445 modest_account_mgr_set_string (self, name,
446 MODEST_ACCOUNT_EMAIL,
448 modest_account_mgr_set_retrieve_type (self, name,
451 /* Notify the observers */
452 g_signal_emit (self, signals[ACCOUNT_INSERTED_SIGNAL], 0, name);
454 /* if no default account has been defined yet, do so now */
455 default_account = modest_account_mgr_get_default_account (self);
456 if (!default_account)
457 modest_account_mgr_set_default_account (self, name);
458 g_free (default_account);
460 /* (re)set the automatic account update */
461 modest_platform_set_update_interval
462 (modest_conf_get_int (priv->modest_conf, MODEST_CONF_UPDATE_INTERVAL, NULL));
469 modest_account_mgr_add_server_account (ModestAccountMgr * self,
471 const gchar *hostname,
473 const gchar *username,
474 const gchar *password,
475 ModestTransportStoreProtocol proto,
476 ModestConnectionProtocol security,
477 ModestAuthProtocol auth)
479 ModestAccountMgrPrivate *priv;
484 g_return_val_if_fail (MODEST_IS_ACCOUNT_MGR(self), FALSE);
485 g_return_val_if_fail (name, FALSE);
486 g_return_val_if_fail (strchr(name, '/') == NULL, FALSE);
488 priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
491 key = _modest_account_mgr_get_account_keyname_cached (priv, name, MODEST_ACCOUNT_HOSTNAME, TRUE);
492 if (modest_conf_key_exists (priv->modest_conf, key, &err)) {
493 g_printerr ("modest: server account '%s' already exists\n", name);
499 modest_conf_set_string (priv->modest_conf, key, null_means_empty(hostname), &err);
501 g_printerr ("modest: failed to set %s: %s\n", key, err->message);
509 key = _modest_account_mgr_get_account_keyname_cached (priv, name, MODEST_ACCOUNT_USERNAME, TRUE);
510 ok = modest_conf_set_string (priv->modest_conf, key, null_means_empty (username), &err);
512 g_printerr ("modest: failed to set %s: %s\n", key, err->message);
521 key = _modest_account_mgr_get_account_keyname_cached (priv, name, MODEST_ACCOUNT_PASSWORD, TRUE);
522 ok = modest_conf_set_string (priv->modest_conf, key, null_means_empty (password), &err);
524 g_printerr ("modest: failed to set %s: %s\n", key, err->message);
532 key = _modest_account_mgr_get_account_keyname_cached (priv, name, MODEST_ACCOUNT_PROTO, TRUE);
533 ok = modest_conf_set_string (priv->modest_conf, key,
534 modest_protocol_info_get_transport_store_protocol_name(proto),
537 g_printerr ("modest: failed to set %s: %s\n", key, err->message);
546 key = _modest_account_mgr_get_account_keyname_cached (priv, name, MODEST_ACCOUNT_PORT, TRUE);
547 ok = modest_conf_set_int (priv->modest_conf, key, portnumber, &err);
549 g_printerr ("modest: failed to set %s: %s\n", key, err->message);
558 key = _modest_account_mgr_get_account_keyname_cached (priv, name, MODEST_ACCOUNT_AUTH_MECH, TRUE);
559 ok = modest_conf_set_string (priv->modest_conf, key,
560 modest_protocol_info_get_auth_protocol_name (auth),
563 g_printerr ("modest: failed to set %s: %s\n", key, err->message);
570 /* Add the security settings: */
571 modest_account_mgr_set_server_account_security (self, name, security);
575 g_printerr ("modest: failed to add server account\n");
582 /** modest_account_mgr_add_server_account_uri:
583 * Only used for mbox and maildir accounts.
586 modest_account_mgr_add_server_account_uri (ModestAccountMgr * self,
588 ModestTransportStoreProtocol proto,
591 ModestAccountMgrPrivate *priv;
595 g_return_val_if_fail (MODEST_IS_ACCOUNT_MGR(self), FALSE);
596 g_return_val_if_fail (name, FALSE);
597 g_return_val_if_fail (strchr(name, '/') == NULL, FALSE);
598 g_return_val_if_fail (uri, FALSE);
600 priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
603 key = _modest_account_mgr_get_account_keyname_cached (priv, name, MODEST_ACCOUNT_PROTO, TRUE);
604 ok = modest_conf_set_string (priv->modest_conf, key,
605 modest_protocol_info_get_transport_store_protocol_name(proto),
609 g_printerr ("modest: failed to set proto\n");
614 key = _modest_account_mgr_get_account_keyname_cached (priv, name, MODEST_ACCOUNT_URI, TRUE);
615 ok = modest_conf_set_string (priv->modest_conf, key, uri, NULL);
618 g_printerr ("modest: failed to set uri\n");
625 * Utility function used by modest_account_mgr_remove_account
628 real_remove_account (ModestConf *conf,
629 const gchar *acc_name,
630 gboolean server_account)
635 key = _modest_account_mgr_get_account_keyname (acc_name, NULL, server_account);
636 modest_conf_remove_key (conf, key, &err);
639 g_printerr ("modest: error removing key: %s\n", err->message);
646 modest_account_mgr_remove_account (ModestAccountMgr * self,
649 ModestAccountMgrPrivate *priv;
650 gchar *default_account_name, *store_acc_name, *transport_acc_name;
651 gboolean default_account_deleted;
653 g_return_val_if_fail (MODEST_IS_ACCOUNT_MGR(self), FALSE);
654 g_return_val_if_fail (name, FALSE);
656 if (!modest_account_mgr_account_exists (self, name, FALSE)) {
657 g_printerr ("modest: %s: account '%s' does not exist\n", __FUNCTION__, name);
661 priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
662 default_account_deleted = FALSE;
664 /* If this was the default, then remove that setting: */
665 default_account_name = modest_account_mgr_get_default_account (self);
666 if (default_account_name && (strcmp (default_account_name, name) == 0)) {
667 modest_account_mgr_unset_default_account (self);
668 default_account_deleted = TRUE;
670 g_free (default_account_name);
672 /* Delete transport and store accounts */
673 store_acc_name = modest_account_mgr_get_string (self, name,
674 MODEST_ACCOUNT_STORE_ACCOUNT, FALSE);
676 real_remove_account (priv->modest_conf, store_acc_name, TRUE);
678 transport_acc_name = modest_account_mgr_get_string (self, name,
679 MODEST_ACCOUNT_TRANSPORT_ACCOUNT, FALSE);
680 if (transport_acc_name)
681 real_remove_account (priv->modest_conf, transport_acc_name, TRUE);
683 /* Remove the modest account */
684 real_remove_account (priv->modest_conf, name, FALSE);
686 if (default_account_deleted) {
687 /* pick another one as the new default account. We do
688 this *after* deleting the keys, because otherwise a
689 call to account_names will retrieve also the
691 modest_account_mgr_set_first_account_as_default (self);
694 /* Notify the observers. We do this *after* deleting
695 the keys, because otherwise a call to account_names
696 will retrieve also the deleted account */
697 g_signal_emit (G_OBJECT(self), signals[ACCOUNT_REMOVED_SIGNAL], 0, name);
699 /* if this was the last account, stop any auto-updating */
700 /* (re)set the automatic account update */
701 GSList *acc_names = modest_account_mgr_account_names (self, TRUE);
703 modest_platform_set_update_interval (0);
704 /* it was the last account, the has_account / has_enabled_account
707 priv->has_accounts = priv->has_enabled_accounts = FALSE;
709 modest_account_mgr_free_account_names (acc_names);
716 /* strip the first /n/ character from each element
717 * caller must make sure all elements are strings with
718 * length >= n, and also that data can be freed.
722 strip_prefix_from_elements (GSList * lst, guint n)
725 memmove (lst->data, lst->data + n,
726 strlen(lst->data) - n + 1);
733 modest_account_mgr_account_names (ModestAccountMgr * self, gboolean only_enabled)
736 ModestAccountMgrPrivate *priv;
739 const size_t prefix_len = strlen (MODEST_ACCOUNT_NAMESPACE "/");
741 g_return_val_if_fail (self, NULL);
743 priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
744 accounts = modest_conf_list_subkeys (priv->modest_conf,
745 MODEST_ACCOUNT_NAMESPACE, &err);
748 g_printerr ("modest: failed to get subkeys (%s): %s\n",
749 MODEST_ACCOUNT_NAMESPACE, err->message);
751 return NULL; /* assume accounts did not get value when err is set...*/
754 strip_prefix_from_elements (accounts, prefix_len);
756 GSList *result = NULL;
758 /* Unescape the keys to get the account names: */
759 GSList *iter = accounts;
764 const gchar* account_name_key = (const gchar*)iter->data;
765 gchar* unescaped_name = account_name_key ?
766 modest_conf_key_unescape (account_name_key)
771 if (unescaped_name &&
772 !modest_account_mgr_get_bool (self, unescaped_name,
773 MODEST_ACCOUNT_ENABLED, FALSE))
777 /* Ignore modest accounts whose server accounts don't exist:
778 * (We could be getting this list while the account is being deleted,
779 * while the child server accounts have already been deleted, but the
780 * parent modest account already exists.
783 gchar* server_account_name = modest_account_mgr_get_string
784 (self, account_name_key, MODEST_ACCOUNT_STORE_ACCOUNT,
786 if (server_account_name) {
787 if (!modest_account_mgr_account_exists (self, server_account_name, TRUE))
789 g_free (server_account_name);
794 gchar* server_account_name = modest_account_mgr_get_string
795 (self, account_name_key, MODEST_ACCOUNT_TRANSPORT_ACCOUNT,
797 if (server_account_name) {
798 if (!modest_account_mgr_account_exists (self, server_account_name, TRUE))
800 g_free (server_account_name);
805 result = g_slist_append (result, unescaped_name);
807 g_free (unescaped_name);
812 iter = g_slist_next (iter);
816 /* we already freed the strings in the loop */
817 g_slist_free (accounts);
825 modest_account_mgr_free_account_names (GSList *account_names)
827 g_slist_foreach (account_names, (GFunc)g_free, NULL);
828 g_slist_free (account_names);
834 modest_account_mgr_get_string (ModestAccountMgr *self, const gchar *name,
835 const gchar *key, gboolean server_account) {
837 ModestAccountMgrPrivate *priv;
839 const gchar *keyname;
843 g_return_val_if_fail (self, NULL);
844 g_return_val_if_fail (name, NULL);
845 g_return_val_if_fail (key, NULL);
847 priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
849 keyname = _modest_account_mgr_get_account_keyname_cached (priv, name, key, server_account);
851 priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
852 retval = modest_conf_get_string (priv->modest_conf, keyname, &err);
854 g_printerr ("modest: error getting string '%s': %s\n", keyname, err->message);
864 modest_account_mgr_get_int (ModestAccountMgr *self, const gchar *name, const gchar *key,
865 gboolean server_account)
867 ModestAccountMgrPrivate *priv;
869 const gchar *keyname;
873 g_return_val_if_fail (MODEST_IS_ACCOUNT_MGR(self), -1);
874 g_return_val_if_fail (name, -1);
875 g_return_val_if_fail (key, -1);
877 priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
879 keyname = _modest_account_mgr_get_account_keyname_cached (priv, name, key, server_account);
881 retval = modest_conf_get_int (priv->modest_conf, keyname, &err);
883 g_printerr ("modest: error getting int '%s': %s\n", keyname, err->message);
894 modest_account_mgr_get_bool (ModestAccountMgr * self, const gchar *account,
895 const gchar * key, gboolean server_account)
897 ModestAccountMgrPrivate *priv;
899 const gchar *keyname;
903 g_return_val_if_fail (MODEST_IS_ACCOUNT_MGR(self), FALSE);
904 g_return_val_if_fail (account, FALSE);
905 g_return_val_if_fail (key, FALSE);
907 priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
908 ///keyname = _modest_account_mgr_get_account_keyname (account, key, server_account);
910 keyname = _modest_account_mgr_get_account_keyname_cached (priv, account, key, server_account);
912 retval = modest_conf_get_bool (priv->modest_conf, keyname, &err);
914 g_printerr ("modest: error getting bool '%s': %s\n", keyname, err->message);
925 modest_account_mgr_get_list (ModestAccountMgr *self, const gchar *name,
926 const gchar *key, ModestConfValueType list_type,
927 gboolean server_account)
929 ModestAccountMgrPrivate *priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
931 const gchar *keyname;
935 g_return_val_if_fail (MODEST_IS_ACCOUNT_MGR(self), NULL);
936 g_return_val_if_fail (name, NULL);
937 g_return_val_if_fail (key, NULL);
939 priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
941 keyname = _modest_account_mgr_get_account_keyname_cached (priv, name, key,
944 retval = modest_conf_get_list (priv->modest_conf, keyname, list_type, &err);
946 g_printerr ("modest: error getting list '%s': %s\n", keyname,
956 modest_account_mgr_set_string (ModestAccountMgr * self,
960 gboolean server_account)
962 ModestAccountMgrPrivate *priv;
964 const gchar *keyname;
968 g_return_val_if_fail (MODEST_IS_ACCOUNT_MGR(self), FALSE);
969 g_return_val_if_fail (name, FALSE);
970 g_return_val_if_fail (key, FALSE);
972 priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
974 keyname = _modest_account_mgr_get_account_keyname_cached (priv, name, key, server_account);
976 retval = modest_conf_set_string (priv->modest_conf, keyname, val, &err);
978 g_printerr ("modest: error setting string '%s': %s\n", keyname, err->message);
986 modest_account_mgr_set_int (ModestAccountMgr * self, const gchar * name,
987 const gchar * key, int val, gboolean server_account)
989 ModestAccountMgrPrivate *priv;
990 const gchar *keyname;
994 g_return_val_if_fail (MODEST_IS_ACCOUNT_MGR(self), FALSE);
995 g_return_val_if_fail (name, FALSE);
996 g_return_val_if_fail (key, FALSE);
998 priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
1000 keyname = _modest_account_mgr_get_account_keyname_cached (priv, name, key, server_account);
1002 retval = modest_conf_set_int (priv->modest_conf, keyname, val, &err);
1004 g_printerr ("modest: error setting int '%s': %s\n", keyname, err->message);
1008 /* check whether this field is one of those interesting for the
1009 * "account-updated" signal */
1010 if (strcmp(key, MODEST_ACCOUNT_LAST_UPDATED) == 0) {
1011 g_signal_emit (G_OBJECT(self), signals[ACCOUNT_UPDATED_SIGNAL],
1021 modest_account_mgr_set_bool (ModestAccountMgr * self, const gchar * name,
1022 const gchar * key, gboolean val, gboolean server_account)
1024 ModestAccountMgrPrivate *priv;
1026 const gchar *keyname;
1030 g_return_val_if_fail (MODEST_IS_ACCOUNT_MGR(self), FALSE);
1031 g_return_val_if_fail (name, FALSE);
1032 g_return_val_if_fail (key, FALSE);
1034 priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
1035 keyname = _modest_account_mgr_get_account_keyname_cached (priv, name, key, server_account);
1037 retval = modest_conf_set_bool (priv->modest_conf, keyname, val, &err);
1039 g_printerr ("modest: error setting bool '%s': %s\n", keyname, err->message);
1049 modest_account_mgr_set_list (ModestAccountMgr *self,
1053 ModestConfValueType list_type,
1054 gboolean server_account)
1056 ModestAccountMgrPrivate *priv;
1057 const gchar *keyname;
1061 g_return_val_if_fail (self, FALSE);
1062 g_return_val_if_fail (name, FALSE);
1063 g_return_val_if_fail (key, FALSE);
1064 g_return_val_if_fail (val, FALSE);
1066 priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
1068 keyname = _modest_account_mgr_get_account_keyname_cached (priv, name, key, server_account);
1070 retval = modest_conf_set_list (priv->modest_conf, keyname, val, list_type, &err);
1072 g_printerr ("modest: error setting list '%s': %s\n", keyname, err->message);
1081 modest_account_mgr_account_exists (ModestAccountMgr * self, const gchar* name,
1082 gboolean server_account)
1084 ModestAccountMgrPrivate *priv;
1086 const gchar *keyname;
1090 g_return_val_if_fail (self, FALSE);
1091 g_return_val_if_fail (name, FALSE);
1093 priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
1094 keyname = _modest_account_mgr_get_account_keyname_cached (priv, name, NULL, server_account);
1095 retval = modest_conf_key_exists (priv->modest_conf, keyname, &err);
1097 g_printerr ("modest: error determining existance of '%s': %s\n", keyname,
1106 modest_account_mgr_account_with_display_name_exists (ModestAccountMgr *self,
1107 const gchar *display_name)
1109 GSList *account_names = NULL;
1110 GSList *cursor = NULL;
1112 cursor = account_names = modest_account_mgr_account_names (self,
1113 TRUE /* enabled accounts, because disabled accounts are not user visible. */);
1115 gboolean found = FALSE;
1117 /* Look at each non-server account to check their display names; */
1119 const gchar *account_name = (gchar*)cursor->data;
1120 const gchar *cursor_display_name;
1122 ModestAccountSettings *settings = modest_account_mgr_load_account_settings (self, account_name);
1124 g_printerr ("modest: failed to get account data for %s\n", account_name);
1128 cursor_display_name = modest_account_settings_get_display_name (settings);
1129 if(cursor_display_name && (strcmp (cursor_display_name, display_name) == 0)) {
1131 g_object_unref (settings);
1135 g_object_unref (settings);
1136 cursor = cursor->next;
1138 modest_account_mgr_free_account_names (account_names);
1139 account_names = NULL;
1148 modest_account_mgr_unset (ModestAccountMgr *self, const gchar *name,
1149 const gchar *key, gboolean server_account)
1151 ModestAccountMgrPrivate *priv;
1153 const gchar *keyname;
1157 g_return_val_if_fail (MODEST_IS_ACCOUNT_MGR(self), FALSE);
1158 g_return_val_if_fail (name, FALSE);
1159 g_return_val_if_fail (key, FALSE);
1161 priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
1162 keyname = _modest_account_mgr_get_account_keyname_cached (priv, name, key, server_account);
1164 retval = modest_conf_remove_key (priv->modest_conf, keyname, &err);
1166 g_printerr ("modest: error unsetting'%s': %s\n", keyname,
1175 _modest_account_mgr_account_from_key (const gchar *key, gboolean *is_account_key, gboolean *is_server_account)
1177 /* Initialize input parameters: */
1179 *is_account_key = FALSE;
1181 if (is_server_account)
1182 *is_server_account = FALSE;
1184 const gchar* account_ns = MODEST_ACCOUNT_NAMESPACE "/";
1185 const gchar* server_account_ns = MODEST_SERVER_ACCOUNT_NAMESPACE "/";
1187 gchar *account = NULL;
1189 /* determine whether it's an account or a server account,
1190 * based on the prefix */
1191 if (g_str_has_prefix (key, account_ns)) {
1193 if (is_server_account)
1194 *is_server_account = FALSE;
1196 account = g_strdup (key + strlen (account_ns));
1198 } else if (g_str_has_prefix (key, server_account_ns)) {
1200 if (is_server_account)
1201 *is_server_account = TRUE;
1203 account = g_strdup (key + strlen (server_account_ns));
1207 /* if there are any slashes left in the key, it's not
1208 * the toplevel entry for an account
1210 cursor = strstr(account, "/");
1212 if (is_account_key && cursor)
1213 *is_account_key = TRUE;
1215 /* put a NULL where the first slash was */
1220 /* The key is an escaped string, so unescape it to get the actual account name: */
1221 gchar *unescaped_name = modest_conf_key_unescape (account);
1223 return unescaped_name;
1232 /* optimization: only with non-alphanum chars, escaping is needed */
1233 inline static gboolean
1234 is_alphanum (const gchar* str)
1236 const gchar *cursor;
1237 for (cursor = str; cursor && *cursor; ++cursor) {
1238 const char c = *cursor;
1239 /* we cannot trust isalnum(3), because it might consider locales */
1240 /* numbers ALPHA alpha */
1241 if (!((c>=48 && c<=57)||(c>=65 && c<=90)||(c>=97 && c<=122)))
1250 /* must be freed by caller */
1252 _modest_account_mgr_get_account_keyname (const gchar *account_name, const gchar* name,
1253 gboolean server_account)
1255 gchar *retval = NULL;
1256 gchar *namespace = server_account ? MODEST_SERVER_ACCOUNT_NAMESPACE : MODEST_ACCOUNT_NAMESPACE;
1257 gchar *escaped_account_name, *escaped_name;
1260 return g_strdup (namespace);
1262 /* optimization: only escape names when need to be escaped */
1263 if (is_alphanum (account_name))
1264 escaped_account_name = (gchar*)account_name;
1266 escaped_account_name = modest_conf_key_escape (account_name);
1268 if (is_alphanum (name))
1269 escaped_name = (gchar*)name;
1271 escaped_name = modest_conf_key_escape (name);
1272 //////////////////////////////////////////////////////////////
1274 if (escaped_account_name && escaped_name)
1275 retval = g_strconcat (namespace, "/", escaped_account_name, "/", escaped_name, NULL);
1276 else if (escaped_account_name)
1277 retval = g_strconcat (namespace, "/", escaped_account_name, NULL);
1280 if (!retval || !modest_conf_key_is_valid (retval)) {
1281 g_warning ("%s: Generated conf key was invalid: %s", __FUNCTION__,
1282 retval ? retval: "<empty>");
1287 /* g_free is only needed if we actually allocated anything */
1288 if (name != escaped_name)
1289 g_free (escaped_name);
1290 if (account_name != escaped_account_name)
1291 g_free (escaped_account_name);
1296 static const gchar *
1297 _modest_account_mgr_get_account_keyname_cached (ModestAccountMgrPrivate *priv,
1298 const gchar* account_name,
1302 GHashTable *hash = is_server ? priv->server_account_key_hash : priv->account_key_hash;
1303 GHashTable *account_hash;
1305 const gchar *search_name;
1308 return is_server ? MODEST_SERVER_ACCOUNT_NAMESPACE : MODEST_ACCOUNT_NAMESPACE;
1310 search_name = name ? name : "<dummy>";
1312 account_hash = g_hash_table_lookup (hash, account_name);
1313 if (!account_hash) { /* no hash for this account yet? create it */
1314 account_hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
1315 key = _modest_account_mgr_get_account_keyname (account_name, name, is_server);
1316 g_hash_table_insert (account_hash, g_strdup(search_name), key);
1317 g_hash_table_insert (hash, g_strdup(account_name), account_hash);
1321 /* we have a hash for this account, but do we have the key? */
1322 key = g_hash_table_lookup (account_hash, search_name);
1324 key = _modest_account_mgr_get_account_keyname (account_name, name, is_server);
1325 g_hash_table_insert (account_hash, g_strdup(search_name), key);
1333 modest_account_mgr_has_accounts (ModestAccountMgr* self, gboolean enabled)
1335 ModestAccountMgrPrivate* priv;
1336 GSList *account_names;
1337 gboolean accounts_exist;
1339 g_return_val_if_fail (MODEST_IS_ACCOUNT_MGR(self), FALSE);
1341 priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
1343 if (enabled && priv->has_enabled_accounts)
1345 else if (priv->has_accounts)
1348 /* Check that at least one account exists: */
1349 account_names = modest_account_mgr_account_names (self,enabled);
1350 accounts_exist = account_names != NULL;
1351 modest_account_mgr_free_account_names (account_names);
1352 account_names = NULL;
1356 priv->has_enabled_accounts = accounts_exist;
1358 priv->has_accounts = accounts_exist;
1360 return accounts_exist;
1364 compare_account_name(gconstpointer a, gconstpointer b)
1366 const gchar* account_name = (const gchar*) a;
1367 const gchar* account_name2 = (const gchar*) b;
1368 return strcmp(account_name, account_name2);
1372 modest_account_mgr_set_account_busy(ModestAccountMgr* self,
1373 const gchar* account_name,
1376 ModestAccountMgrPrivate* priv;
1378 g_return_if_fail (MODEST_IS_ACCOUNT_MGR(self));
1379 g_return_if_fail (account_name);
1381 priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
1383 GSList *account_names = modest_account_mgr_account_names (self, TRUE);
1384 GSList* account = g_slist_find_custom(account_names, account_name,
1385 (GCompareFunc) compare_account_name);
1387 if (account && !modest_account_mgr_account_is_busy(self, account_name)) {
1388 priv->busy_accounts = g_slist_append(priv->busy_accounts, g_strdup(account_name));
1389 g_signal_emit (G_OBJECT(self), signals[ACCOUNT_BUSY_SIGNAL],
1390 0, account_name, TRUE);
1392 modest_account_mgr_free_account_names (account_names);
1393 account_names = NULL;
1396 g_slist_find_custom(priv->busy_accounts, account_name, (GCompareFunc) compare_account_name);
1399 g_free(account->data);
1400 priv->busy_accounts = g_slist_delete_link(priv->busy_accounts, account);
1401 g_signal_emit (G_OBJECT(self), signals[ACCOUNT_BUSY_SIGNAL],
1402 0, account_name, FALSE);
1408 modest_account_mgr_account_is_busy (ModestAccountMgr* self, const gchar* account_name)
1410 ModestAccountMgrPrivate* priv;
1412 g_return_val_if_fail (MODEST_IS_ACCOUNT_MGR(self), FALSE);
1413 g_return_val_if_fail (account_name, FALSE);
1415 priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
1417 return (g_slist_find_custom(priv->busy_accounts, account_name, (GCompareFunc) compare_account_name)
1422 modest_account_mgr_notify_account_update (ModestAccountMgr* self,
1423 const gchar *server_account_name)
1425 ModestTransportStoreProtocol proto;
1426 ModestAccountMgrPrivate* priv;
1427 gchar *proto_name = NULL;
1429 g_return_if_fail (self);
1430 g_return_if_fail (server_account_name);
1432 priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
1435 proto_name = modest_account_mgr_get_string (self, server_account_name,
1436 MODEST_ACCOUNT_PROTO, TRUE);
1438 g_free (proto_name);
1439 g_return_if_reached ();
1441 proto = modest_protocol_info_get_transport_store_protocol (proto_name);
1442 g_free (proto_name);
1444 /* there is some update in the account, so we can't
1445 * be sure about whether there are still enabled accounts...
1447 priv->has_enabled_accounts = FALSE;
1448 priv->has_accounts = FALSE;
1450 /* Emit "update-account" */
1451 g_signal_emit (G_OBJECT(self),
1452 signals[ACCOUNT_CHANGED_SIGNAL], 0,
1453 server_account_name,
1454 (modest_protocol_info_protocol_is_store (proto)) ?
1455 TNY_ACCOUNT_TYPE_STORE :
1456 TNY_ACCOUNT_TYPE_TRANSPORT);
1461 modest_account_mgr_set_default_account (ModestAccountMgr *self, const gchar* account)
1466 g_return_val_if_fail (self, FALSE);
1467 g_return_val_if_fail (account, FALSE);
1468 g_return_val_if_fail (modest_account_mgr_account_exists (self, account, FALSE),
1471 conf = MODEST_ACCOUNT_MGR_GET_PRIVATE (self)->modest_conf;
1473 /* Change the default account and notify */
1474 retval = modest_conf_set_string (conf, MODEST_CONF_DEFAULT_ACCOUNT, account, NULL);
1476 g_signal_emit (G_OBJECT(self), signals[DEFAULT_ACCOUNT_CHANGED_SIGNAL], 0);
1483 modest_account_mgr_get_default_account (ModestAccountMgr *self)
1489 g_return_val_if_fail (self, NULL);
1491 conf = MODEST_ACCOUNT_MGR_GET_PRIVATE (self)->modest_conf;
1492 account = modest_conf_get_string (conf, MODEST_CONF_DEFAULT_ACCOUNT, &err);
1495 g_printerr ("modest: failed to get '%s': %s\n",
1496 MODEST_CONF_DEFAULT_ACCOUNT, err->message);
1503 if (account && !modest_account_mgr_account_exists (self, account, FALSE)) {
1504 g_printerr ("modest: default account does not exist\n");
1513 modest_account_mgr_unset_default_account (ModestAccountMgr *self)
1518 g_return_val_if_fail (self, FALSE);
1520 conf = MODEST_ACCOUNT_MGR_GET_PRIVATE (self)->modest_conf;
1522 retval = modest_conf_remove_key (conf, MODEST_CONF_DEFAULT_ACCOUNT, NULL /* err */);
1525 g_signal_emit (G_OBJECT(self), signals[DEFAULT_ACCOUNT_CHANGED_SIGNAL], 0);
1532 modest_account_mgr_get_display_name (ModestAccountMgr *self,
1535 return modest_account_mgr_get_string (self, name, MODEST_ACCOUNT_DISPLAY_NAME, FALSE);
1539 modest_account_mgr_set_display_name (ModestAccountMgr *self,
1540 const gchar *account_name,
1541 const gchar *display_name)
1543 modest_account_mgr_set_string (self,
1545 MODEST_ACCOUNT_DISPLAY_NAME,
1547 FALSE /* not server account */);
1549 /* Notify about the change in the display name */
1550 g_signal_emit (self, signals[DISPLAY_NAME_CHANGED_SIGNAL], 0, account_name);