* apllied today's changes to the gtk-glade ui to the hildon ui
[modest] / src / modest-tny-account-store.c
index f5aa9e3..e9fba72 100644 (file)
@@ -39,9 +39,19 @@ enum {
        LAST_SIGNAL
 };
 
+/* Password Status */
+enum {
+        PW_NOT_INVALID,
+        PW_INVALID,
+};
+
+static const gchar *transport_protocols[] = { "smtp", NULL };
+
 typedef struct _ModestTnyAccountStorePrivate ModestTnyAccountStorePrivate;
 struct _ModestTnyAccountStorePrivate {
 
+       GMutex *store_lock;
+       GMutex *transport_lock;
        GList *store_accounts;
        GList *transport_accounts;
        gchar *cache_dir;
@@ -49,7 +59,8 @@ struct _ModestTnyAccountStorePrivate {
        TnySessionCamel *tny_session_camel;
        TnyDeviceIface  *device;
 
-       ModestAccountMgr *modest_acc_mgr;
+        ModestAccountMgr *modest_acc_mgr;
+        gint pw_invalid;
 };
 #define MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(o)      (G_TYPE_INSTANCE_GET_PRIVATE((o), \
                                                       MODEST_TYPE_TNY_ACCOUNT_STORE, \
@@ -122,11 +133,15 @@ modest_tny_account_store_init (ModestTnyAccountStore *obj)
        priv->modest_acc_mgr         = NULL;
        priv->device                 = NULL;
 
+       priv->store_lock             = NULL;
+       priv->transport_lock         = NULL;
        priv->store_accounts         = NULL;
        priv->transport_accounts     = NULL;
        priv->cache_dir              = NULL;
 
-       priv->tny_session_camel      = NULL;
+        priv->tny_session_camel      = NULL;
+        /* Meaning: if not indicated otherwise, we have valid password data */
+        priv->pw_invalid             = PW_NOT_INVALID;
 }
 
 
@@ -148,26 +163,260 @@ free_gobject_list (GList *list)
        return NULL;
 }
 
+static gchar*
+get_password (TnyAccountIface *account,
+              const gchar *prompt,
+              gboolean *cancel) {
+
+       const gchar *key;
+       const TnyAccountStoreIface *account_store;
+       ModestTnyAccountStore *self;
+       ModestTnyAccountStorePrivate *priv;
+       gchar *retval;
+
+       g_return_val_if_fail (account, NULL);
+
+       key = tny_account_iface_get_id (account);
+       account_store = tny_account_iface_get_account_store(account);
+
+       self = MODEST_TNY_ACCOUNT_STORE (account_store);
+       priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
+
+        if (priv->pw_invalid==PW_NOT_INVALID) {
+                retval = modest_account_mgr_get_server_account_string (priv->modest_acc_mgr,
+                                                                       key,
+                                                                       MODEST_ACCOUNT_PASSWORD,
+                                                                       NULL);
+        } else {
+                g_signal_emit(G_OBJECT(self), signals[PASSWORD_REQUESTED_SIGNAL], 0, key);
+                priv->pw_invalid=PW_NOT_INVALID;
+                retval=NULL;
+        }
+        return retval;
+}
+
+
+static void
+forget_password (TnyAccountIface *account) {
+
+       ModestTnyAccountStore *self;
+       ModestTnyAccountStorePrivate *priv;
+       const TnyAccountStoreIface *account_store;
+
+        account_store = tny_account_iface_get_account_store(account);
+       self = MODEST_TNY_ACCOUNT_STORE (account_store);
+        priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
+
+        priv->pw_invalid=PW_INVALID;
+}
+
+
+static TnyAccountIface*
+tny_account_from_key (ModestTnyAccountStore *self, const gchar *key,
+                     gboolean is_store)
+{
+       TnyAccountIface *tny_account;
+       ModestTnyAccountStorePrivate *priv;
+       gchar *val;
+
+       g_return_val_if_fail (self, NULL);
+       g_return_val_if_fail (key, NULL);
+
+       priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
+
+       /* is it a store or a transport? */
+       if (is_store)
+               tny_account = TNY_ACCOUNT_IFACE(tny_store_account_new ());
+       else
+               tny_account = TNY_ACCOUNT_IFACE(tny_transport_account_new ());
+
+       if (!tny_account) {
+               g_warning ("failed to create new tny %s account",
+                          is_store ? "store" : "transport");
+               return NULL;
+       }
+
+       tny_account_iface_set_account_store (TNY_ACCOUNT_IFACE(tny_account),
+                                            TNY_ACCOUNT_STORE_IFACE(self));
+       /* id */
+       tny_account_iface_set_id (tny_account, key);
+       tny_account_iface_set_name (tny_account, key);
+
+       /* proto */
+       val = modest_account_mgr_get_server_account_string (priv->modest_acc_mgr, key,
+                                                           MODEST_ACCOUNT_PROTO, NULL);
+       if (val) {
+               tny_account_iface_set_proto (tny_account, val);
+               g_free (val);
+       } else {
+               g_warning ("protocol not defined for %s", key);
+               g_object_unref (G_OBJECT(tny_account));
+               return NULL;
+       }
+
+       /* hostname */
+       val = modest_account_mgr_get_server_account_string (priv->modest_acc_mgr, key,
+                                                           MODEST_ACCOUNT_HOSTNAME,
+                                                           NULL);
+       if (val) {
+               tny_account_iface_set_hostname (tny_account, val);
+               g_free (val);
+       }
+
+
+       /* username */
+       val = modest_account_mgr_get_server_account_string (priv->modest_acc_mgr, key,
+                                                           MODEST_ACCOUNT_USERNAME,
+                                                           NULL);
+       if (val) {
+               tny_account_iface_set_user (tny_account, val);
+               g_free (val);
+       }
+
+       tny_account_iface_set_pass_func (tny_account, get_password);
+       tny_account_iface_set_forget_pass_func (tny_account, forget_password);
+
+       return tny_account;
+}
+
+
+static GList*
+tny_accounts_from_server_accounts (ModestTnyAccountStore *self, GSList *accounts,
+                                  gboolean is_store)
+{
+       GSList *cursor = accounts;
+       GList *tny_accounts = NULL;
+
+       g_return_val_if_fail (self, NULL);
+
+       while (cursor) {
+               TnyAccountIface *tny_account;
+               tny_account = tny_account_from_key (self, (gchar*)cursor->data,
+                                                   is_store);
+               if (!tny_account) {
+                       g_warning ("could not create tnyaccount for %s",
+                                  (gchar*)cursor->data);
+               } else {
+                       tny_accounts =
+                               g_list_append (tny_accounts, tny_account);
+               }
+               cursor = cursor->next;
+       }
+
+       return tny_accounts;
+}
+
 
-static void 
+static void
 manager_new_account (ModestAccountMgr *modest_acc_mgr, gchar *name, gpointer data)
 {
+       ModestTnyAccountStore *self = data;
+       ModestTnyAccountStorePrivate *priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
+       TnyAccountIface *new_account;
+       gchar *proto;
+       gint i = 0;
+       gboolean is_store = TRUE;
+
        g_print ("new account signal %s\n", name);
+
+       proto = modest_account_mgr_get_server_account_string (priv->modest_acc_mgr, name,
+                                                           MODEST_ACCOUNT_PROTO, NULL);
+       if (!proto) {
+               g_printerr ("Cannot add account: unknown type.");
+               return;
+       }
+
+       while (transport_protocols [i]) {
+               if (!strcmp (transport_protocols [i], proto)) {
+                       is_store = FALSE;
+                       break;
+               }
+               i++;
+       }
+
+       /* fill account lists */
+       if (!priv->store_accounts)
+               modest_tny_account_store_get_store_accounts (TNY_ACCOUNT_STORE_IFACE(self));
+       if (!priv->transport_accounts)
+               modest_tny_account_store_get_transport_accounts (TNY_ACCOUNT_STORE_IFACE(self));
+
+
+       if (is_store) {
+                       new_account = tny_account_from_key (self, name, is_store);
+                       g_mutex_lock (priv->store_lock);
+                       priv->store_accounts = g_list_append (priv->store_accounts, new_account);
+                       g_mutex_unlock (priv->store_lock);
+       } else {
+                       new_account = tny_account_from_key (self, name, is_store);
+                       g_mutex_lock (priv->transport_lock);
+                       priv->transport_accounts = g_list_append (priv->transport_accounts, new_account);
+                       g_mutex_unlock (priv->transport_lock);
+       }
+       g_signal_emit (self,
+               tny_account_store_iface_signals [TNY_ACCOUNT_STORE_IFACE_ACCOUNT_INSERTED], 0, new_account);
 }
 
 
-static void 
-manager_remove_account (ModestAccountMgr *modest_acc_mgr,gchar *name, gpointer data)
+static void
+manager_remove_account (ModestAccountMgr *modest_acc_mgr, gchar *name, gpointer data)
 {
        g_print ("remove account signal %s\n", name);
 }
 
 
-static void 
-manager_change_account (ModestAccountMgr *modest_acc_mgr, gchar *accountname, 
+static void
+manager_change_account (ModestAccountMgr *modest_acc_mgr, gchar *accountname,
        gchar *key, gchar* value, gpointer data)
 {
+       ModestTnyAccountStore *self = data;
+       ModestTnyAccountStorePrivate *priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
+       GList *iter;
+       TnyAccountIface *account = NULL;
+
        g_print ("account change signal: account: %s key: %s value: %s\n", accountname, key, value);
+
+       /* fill account lists */
+       if (!priv->store_accounts)
+               modest_tny_account_store_get_store_accounts (TNY_ACCOUNT_STORE_IFACE(self));
+       if (!priv->transport_accounts)
+               modest_tny_account_store_get_transport_accounts (TNY_ACCOUNT_STORE_IFACE(self));
+
+       for (iter = priv->store_accounts; iter; iter = iter->next) {
+               TnyAccountIface *acc = iter->data;
+               if (!strcmp (tny_account_iface_get_name (acc), accountname)) {
+                       account = acc;
+                       break;
+               }
+       }
+
+       if (!account)
+               for (iter = priv->transport_accounts; iter; iter = iter->next) {
+                       TnyAccountIface *acc = iter->data;
+                       if (!strcmp (tny_account_iface_get_name (acc), accountname)) {
+                               account = acc;
+                               break;
+                       }
+               }
+
+       if (!account) {
+               g_printerr ("Couldn't find account - returning without applying changes.");
+               return;
+       }
+
+       g_mutex_lock (priv->store_lock);
+       g_mutex_lock (priv->transport_lock);
+
+       if (!strcmp (key, MODEST_ACCOUNT_HOSTNAME))
+               tny_account_iface_set_hostname (account, value);
+       if (!strcmp (key, MODEST_ACCOUNT_USERNAME))
+               tny_account_iface_set_user (account, value);
+
+       g_mutex_unlock (priv->transport_lock);
+       g_mutex_unlock (priv->store_lock);
+
+       /* TODO: handle protocol and password changes */
+       g_signal_emit (self,
+               tny_account_store_iface_signals [TNY_ACCOUNT_STORE_IFACE_ACCOUNTS_RELOADED], 0);
 }
 
 
@@ -178,13 +427,13 @@ modest_tny_account_store_finalize (GObject *obj)
        ModestTnyAccountStorePrivate *priv =
                MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
 
-       g_signal_handlers_disconnect_by_func (G_OBJECT (priv->modest_acc_mgr), 
+       g_signal_handlers_disconnect_by_func (G_OBJECT (priv->modest_acc_mgr),
                G_CALLBACK(manager_new_account), NULL);
-       g_signal_handlers_disconnect_by_func (G_OBJECT (priv->modest_acc_mgr), 
+       g_signal_handlers_disconnect_by_func (G_OBJECT (priv->modest_acc_mgr),
                G_CALLBACK(manager_remove_account), NULL);
-       g_signal_handlers_disconnect_by_func (G_OBJECT (priv->modest_acc_mgr), 
+       g_signal_handlers_disconnect_by_func (G_OBJECT (priv->modest_acc_mgr),
                G_CALLBACK(manager_change_account), NULL);
-               
+
        if (priv->modest_acc_mgr) {
                g_object_unref (G_OBJECT(priv->modest_acc_mgr));
                priv->modest_acc_mgr = NULL;
@@ -200,19 +449,27 @@ modest_tny_account_store_finalize (GObject *obj)
                priv->device = NULL;
        }
 
+       g_mutex_lock (priv->store_lock);
        priv->store_accounts     = free_gobject_list (priv->store_accounts);
+       g_mutex_unlock (priv->store_lock);
+
+       g_mutex_lock (priv->transport_lock);
        priv->transport_accounts = free_gobject_list (priv->store_accounts);
+       g_mutex_unlock (priv->transport_lock);
+
+
+       g_mutex_free (priv->store_lock);
+       g_mutex_free (priv->transport_lock);
 
        g_free (priv->cache_dir);
        priv->cache_dir = NULL;
 
-
 }
 
 
 GObject*
-modest_tny_account_store_new (ModestAccountMgr *modest_acc_mgr)
-{
+modest_tny_account_store_new (ModestAccountMgr *modest_acc_mgr) {
+
        GObject *obj;
        ModestTnyAccountStorePrivate *priv;
 
@@ -221,10 +478,13 @@ modest_tny_account_store_new (ModestAccountMgr *modest_acc_mgr)
        obj  = G_OBJECT(g_object_new(MODEST_TYPE_TNY_ACCOUNT_STORE, NULL));
 
        priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(obj);
-       
+
        g_object_ref(G_OBJECT(modest_acc_mgr));
        priv->modest_acc_mgr = modest_acc_mgr;
-       
+
+       priv->store_lock = g_mutex_new ();
+       priv->transport_lock = g_mutex_new ();
+
        priv->device = (TnyDeviceIface*)tny_device_new();
        if (!priv->device) {
                g_warning ("Cannot create Device instance");
@@ -238,60 +498,21 @@ modest_tny_account_store_new (ModestAccountMgr *modest_acc_mgr)
                g_object_unref (obj);
                return NULL;
        }
-       
-       g_signal_connect (G_OBJECT (modest_acc_mgr), "account-add", 
-               G_CALLBACK(manager_new_account), NULL);
-       g_signal_connect (G_OBJECT (modest_acc_mgr), "account-remove", 
-               G_CALLBACK(manager_remove_account), NULL);
-       g_signal_connect (G_OBJECT (modest_acc_mgr), "account-change", 
-               G_CALLBACK(manager_change_account), NULL);
-
-       return obj;
-}
-
-
-static gchar*
-get_password (TnyAccountIface *account, const gchar *prompt, gboolean *cancel)
-{
-       const gchar *key;
-       const TnyAccountStoreIface *account_store;
-       ModestTnyAccountStore *self;
-       ModestTnyAccountStorePrivate *priv;
-       gchar *val;
-
-       g_return_val_if_fail (account, NULL);
-
-       key = tny_account_iface_get_id (account);
-       account_store = tny_account_iface_get_account_store(account);
-
-       self = MODEST_TNY_ACCOUNT_STORE (account_store);
-       priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
-
-       val = modest_account_mgr_get_server_account_string (priv->modest_acc_mgr, key,
-                                                                                               MODEST_ACCOUNT_PASSWORD, NULL);
-       if (!val) {
-               /* FIXME:
-                * append the prompt to the emitted signal,
-                * so the password dialog shows the prompt supplied by the caller of this function.
-                */
-               g_signal_emit (G_OBJECT(self), signals[PASSWORD_REQUESTED_SIGNAL], 0, key);
-       }
-
-       return val;
-}
 
+       g_signal_connect (G_OBJECT (modest_acc_mgr), "account-add",
+               G_CALLBACK(manager_new_account), obj);
+       g_signal_connect (G_OBJECT (modest_acc_mgr), "account-remove",
+               G_CALLBACK(manager_remove_account), obj);
+       g_signal_connect (G_OBJECT (modest_acc_mgr), "account-change",
+               G_CALLBACK(manager_change_account), obj);
 
-static void
-forget_password (TnyAccountIface *account)
-{
-       g_warning (__FUNCTION__);
+       return obj;
 }
 
 
-
 static gboolean
-add_account  (TnyAccountStoreIface *self, TnyAccountIface *account)
-{
+add_account  (TnyAccountStoreIface *self, TnyAccountIface *account) {
+
        TnyAccountIface       *account_iface;
        ModestTnyAccountStore *account_store;
        ModestTnyAccountStorePrivate *priv;
@@ -341,102 +562,6 @@ modest_tny_account_store_add_transport_account  (TnyAccountStoreIface *self,
 }
 
 
-static TnyAccountIface*
-tny_account_from_key (ModestTnyAccountStore *self, const gchar *key,
-                     gboolean is_store)
-{
-       TnyAccountIface *tny_account;
-       ModestTnyAccountStorePrivate *priv;
-       gchar *val;
-
-       g_return_val_if_fail (self, NULL);
-       g_return_val_if_fail (key, NULL);
-
-       priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
-
-       /* is it a store or a transport? */
-       if (is_store)
-               tny_account = TNY_ACCOUNT_IFACE(tny_store_account_new ());
-       else
-               tny_account = TNY_ACCOUNT_IFACE(tny_transport_account_new ());
-
-       if (!tny_account) {
-               g_warning ("failed to create new tny %s account",
-                          is_store ? "store" : "transport");
-               return NULL;
-       }
-
-       tny_account_iface_set_account_store (TNY_ACCOUNT_IFACE(tny_account),
-                                            TNY_ACCOUNT_STORE_IFACE(self));
-       /* id */
-       tny_account_iface_set_id (tny_account, key);
-       tny_account_iface_set_name (tny_account, key);
-       
-       /* proto */
-       val = modest_account_mgr_get_server_account_string (priv->modest_acc_mgr, key,
-                                                           MODEST_ACCOUNT_PROTO, NULL);
-       if (val) {
-               tny_account_iface_set_proto (tny_account, val);
-               g_free (val);
-       } else {
-               g_warning ("protocol not defined for %s", key);
-               g_object_unref (G_OBJECT(tny_account));
-               return NULL;
-       }
-
-       /* hostname */
-       val = modest_account_mgr_get_server_account_string (priv->modest_acc_mgr, key,
-                                                           MODEST_ACCOUNT_HOSTNAME,
-                                                           NULL);
-       if (val) {
-               tny_account_iface_set_hostname (tny_account, val);
-               g_free (val);
-       }
-
-
-       /* username */
-       val = modest_account_mgr_get_server_account_string (priv->modest_acc_mgr, key,
-                                                           MODEST_ACCOUNT_USERNAME,
-                                                           NULL);
-       if (val) {
-               tny_account_iface_set_user (tny_account, val);
-               g_free (val);
-       }
-
-       tny_account_iface_set_pass_func (tny_account, get_password);
-       tny_account_iface_set_forget_pass_func (tny_account, forget_password);
-
-       return tny_account;
-}
-
-
-static GList*
-tny_accounts_from_server_accounts (ModestTnyAccountStore *self, GSList *accounts,
-                                  gboolean is_store)
-{
-       GSList *cursor = accounts;
-       GList *tny_accounts = NULL;
-
-       g_return_val_if_fail (self, NULL);
-
-       while (cursor) {
-               TnyAccountIface *tny_account;
-               tny_account = tny_account_from_key (self, (gchar*)cursor->data,
-                                                   is_store);
-               if (!tny_account) {
-                       g_warning ("could not create tnyaccount for %s",
-                                  (gchar*)cursor->data);
-               } else {
-                       tny_accounts =
-                               g_list_append (tny_accounts, tny_account);
-               }
-               cursor = cursor->next;
-       }
-
-       return tny_accounts;
-}
-
-
 static const GList*
 modest_tny_account_store_get_store_accounts  (TnyAccountStoreIface *iface)
 {
@@ -456,9 +581,11 @@ modest_tny_account_store_get_store_accounts  (TnyAccountStoreIface *iface)
                                                                 MODEST_PROTO_TYPE_STORE,
                                                                 NULL, FALSE);
 
+               g_mutex_lock (priv->store_lock);
                priv->store_accounts = tny_accounts_from_server_accounts (self, accounts, TRUE);
+               g_mutex_unlock (priv->store_lock);
                g_slist_free (accounts);
-       }       
+       }
 
        return priv->store_accounts;
 }
@@ -476,14 +603,16 @@ modest_tny_account_store_get_transport_accounts (TnyAccountStoreIface *iface)
        self = MODEST_TNY_ACCOUNT_STORE(iface);
        priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
 
-       
+
        if (!priv->transport_accounts) {
                accounts =
                        modest_account_mgr_server_account_names (priv->modest_acc_mgr,
                                                                 NULL,
                                                                 MODEST_PROTO_TYPE_TRANSPORT,
                                                                 NULL, FALSE);
+               g_mutex_lock (priv->transport_lock);
                priv->transport_accounts = tny_accounts_from_server_accounts (self, accounts, FALSE);
+               g_mutex_unlock (priv->transport_lock);
                g_slist_free (accounts);
        }