X-Git-Url: http://git.maemo.org/git/?p=modest;a=blobdiff_plain;f=src%2Fmodest-tny-account-store.c;h=d2ecec6b09e63e605aa23724214b9dbf6d22b6cc;hp=9e1db5f18ce0e8e5e3bf227caa66ad48201e7f01;hb=11a7e8bd60ce134adc068ecedefd64faa1dd7ddf;hpb=ab71824e3c4e16f5a6371895236f9d4055d21eca

diff --git a/src/modest-tny-account-store.c b/src/modest-tny-account-store.c
index 9e1db5f..d2ecec6 100644
--- a/src/modest-tny-account-store.c
+++ b/src/modest-tny-account-store.c
@@ -73,7 +73,7 @@ static void    modest_tny_account_store_instance_init (ModestTnyAccountStore *ob
 static void    modest_tny_account_store_init          (gpointer g, gpointer iface_data);
 
 
-static GSList*
+static void
 get_server_accounts  (TnyAccountStore *self, TnyList *list, TnyAccountType type);
 
 
@@ -92,9 +92,17 @@ struct _ModestTnyAccountStorePrivate {
 	TnySessionCamel    *session;
 	TnyDevice          *device;
 	
-	/* we cache them here */
+	/* We cache the lists of accounts here.
+	 * They are created in our get_accounts_func() implementation. */
 	GSList             *store_accounts;
 	GSList             *transport_accounts;
+	
+	/* This is also contained in store_accounts,
+	 * but we cached it temporarily separately, 
+	 * because we create this while creating the transport accounts, 
+	 * but return it when requesting the store accounts: 
+	 */
+	GSList             *store_accounts_outboxes;
 };
 
 #define MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(o)      (G_TYPE_INSTANCE_GET_PRIVATE((o), \
@@ -223,12 +231,16 @@ on_account_removed (ModestAccountMgr *acc_mgr, const gchar *account, gboolean se
 	 */
 	
 	account_list_free (priv->store_accounts);
-	priv->store_accounts = get_server_accounts (TNY_ACCOUNT_STORE(self), NULL, TNY_ACCOUNT_TYPE_STORE);
+	get_server_accounts (TNY_ACCOUNT_STORE(self), NULL, TNY_ACCOUNT_TYPE_STORE);
 	
 	account_list_free (priv->transport_accounts);
-	priv->transport_accounts = get_server_accounts (TNY_ACCOUNT_STORE(self), NULL,
+	get_server_accounts (TNY_ACCOUNT_STORE(self), NULL,
 							TNY_ACCOUNT_TYPE_TRANSPORT);
 		
+	/* TODO: Ref these when we add them? */
+	g_slist_free (priv->store_accounts_outboxes);
+	priv->store_accounts_outboxes = NULL;
+	
 	g_signal_emit (G_OBJECT(self), signals[ACCOUNT_UPDATE_SIGNAL], 0,
 		       account);
 }
@@ -248,15 +260,15 @@ on_account_changed (ModestAccountMgr *acc_mgr, const gchar *account,
 	if (server_account) {
 		if (priv->store_accounts) {
 			account_list_free (priv->store_accounts);
-			priv->store_accounts =
-				get_server_accounts (TNY_ACCOUNT_STORE(self),
+			priv->store_accounts = NULL;
+			get_server_accounts (TNY_ACCOUNT_STORE(self),
 						     NULL, TNY_ACCOUNT_TYPE_STORE);
 		}
 		
 		if (priv->transport_accounts) {
 			account_list_free (priv->transport_accounts);
-			priv->transport_accounts =
-				get_server_accounts (TNY_ACCOUNT_STORE(self), NULL,
+			priv->transport_accounts = NULL;
+			get_server_accounts (TNY_ACCOUNT_STORE(self), NULL,
 						     TNY_ACCOUNT_TYPE_TRANSPORT);
 		}
 	}
@@ -355,7 +367,8 @@ get_password (TnyAccount *account, const gchar *prompt, gboolean *cancel)
 	return pwd;
 }
 
-
+/* tinymail calls this if the connection failed due to an incorrect password.
+ * And it seems to call this for any general connection failure. */
 static void
 forget_password (TnyAccount *account)
 {
@@ -464,7 +477,7 @@ modest_tny_account_store_new (ModestAccountMgr *account_mgr, TnyDevice *device)
 	return MODEST_TNY_ACCOUNT_STORE(obj);
 }
 
-
+/** Fill the TnyList from the appropriate cached GSList of accounts. */
 static void
 get_cached_accounts (TnyAccountStore *self, TnyList *list, TnyAccountType type)
 {
@@ -481,21 +494,67 @@ get_cached_accounts (TnyAccountStore *self, TnyList *list, TnyAccountType type)
 	}
 }
 
+static void
+create_per_account_local_outbox_folders (TnyAccountStore *self)
+{
+	g_return_if_fail (self);
+	
+	ModestTnyAccountStorePrivate *priv = 
+		MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
+	
+	/* printf("DEBUG: %s: priv->store_accounts_outboxes = %p\n", __FUNCTION__, priv->store_accounts_outboxes); */
+	
+	GSList *accounts = NULL;
+	
+	GSList *account_names  = modest_account_mgr_account_names (priv->account_mgr, 
+		TRUE /* including disabled accounts */);
+	
+	GSList *iter = NULL;
+	for (iter = account_names; iter; iter = g_slist_next (iter)) {
+		
+		const gchar* account_name = (const gchar*)iter->data;
+		
+		/* Create a per-account local outbox folder (a _store_ account) 
+		 * for each _transport_ account: */
+		TnyAccount *tny_account_outbox =
+			modest_tny_account_new_for_per_account_local_outbox_folder (
+				priv->account_mgr, account_name, priv->session);
+				
+		accounts = g_slist_append (accounts, tny_account_outbox); /* cache it */
+	};
+	
+	g_slist_free (account_names);
+	
+	priv->store_accounts_outboxes = accounts;
+}
 
-
-/* this function fills the TnyList, and also returns a GSList of the accounts,
- * for caching purposes
+/* This function fills the TnyList, and also stores a GSList of the accounts,
+ * for caching purposes. It creates the TnyAccount objects if necessary.
+ * The @list parameter may be NULL, if you just want to fill the cache.
  */
-static GSList*
+static void
 get_server_accounts  (TnyAccountStore *self, TnyList *list, TnyAccountType type)
 {
-	ModestTnyAccountStorePrivate *priv = NULL;
+	g_return_if_fail (self);
+	
+	/* printf ("DEBUG: %s: list=%p, type=%d\n", __FUNCTION__, list, type); */
+		
+	ModestTnyAccountStorePrivate *priv = 
+		MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
+		
+	/* Do nothing if the accounts are already cached: */
+	if (type == TNY_ACCOUNT_TYPE_STORE) {
+		if (priv->store_accounts)
+			return;
+	} else if (type == TNY_ACCOUNT_TYPE_TRANSPORT) {
+		if (priv->transport_accounts)
+			return;
+	}
+	
 	GSList                       *account_names = NULL, *cursor = NULL;
 	GSList                       *accounts = NULL;
-	
-	priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
 
-	/* these account names, not server_account names */
+	/* These are account names, not server_account names */
 	account_names = modest_account_mgr_account_names (priv->account_mgr,FALSE);
 		
 	for (cursor = account_names; cursor; cursor = cursor->next) {
@@ -504,6 +563,8 @@ get_server_accounts  (TnyAccountStore *self, TnyList *list, TnyAccountType type)
 		
 		/* we get the server_accounts for enabled accounts */
 		if (modest_account_mgr_get_enabled(priv->account_mgr, account_name)) {
+				
+			/* Add the account: */
 			TnyAccount *tny_account = 
 				modest_tny_account_new_from_account (priv->account_mgr,
 								     account_name,
@@ -516,24 +577,114 @@ get_server_accounts  (TnyAccountStore *self, TnyList *list, TnyAccountType type)
 				if (list)
 					tny_list_prepend (list, G_OBJECT(tny_account));
 				
-				accounts = g_slist_append (accounts, tny_account); /* cache it */
+				accounts = g_slist_append (accounts, tny_account); /* cache it */		
 			} else
 				g_printerr ("modest: failed to create account for %s\n",
 					    account_name);
-		}
-		g_free (account_name);
+			}
 	}
-	g_slist_free (account_names);
-
-	/* also, add the local folder pseudo-account */
+	
 	if (type == TNY_ACCOUNT_TYPE_STORE) {
+		/* Also add the local folder pseudo-account: */
 		TnyAccount *tny_account =
 			modest_tny_account_new_for_local_folders (priv->account_mgr, priv->session);
 		if (list)
 			tny_list_prepend (list, G_OBJECT(tny_account));
 		accounts = g_slist_append (accounts, tny_account); /* cache it */
-	}	
-	return accounts;
+	}
+
+	/* And add the connection-specific transport accounts, if any.
+	 * Note that these server account instances might never be used 
+	 * if their connections are never active: */
+	/* Look at each modest account: */
+	if (type == TNY_ACCOUNT_TYPE_TRANSPORT) {
+		GSList *iter_account_names = account_names;
+		while (iter_account_names) {
+			const gchar* account_name = (const gchar*)(iter_account_names->data);
+			GSList *list_specifics = modest_account_mgr_get_list (priv->account_mgr,
+				account_name, 
+				MODEST_ACCOUNT_CONNECTION_SPECIFIC_SMTP_LIST,
+				MODEST_CONF_VALUE_STRING, FALSE);
+				
+			/* Look at each connection-specific transport account for the 
+			 * modest account: */
+			GSList *iter = list_specifics;
+			while (iter) {
+				/* const gchar* this_connection_name = (const gchar*)(iter->data); */
+				iter = g_slist_next (iter);
+				if (iter) {
+					const gchar* transport_account_name = (const gchar*)(iter->data);
+					if (transport_account_name) {
+						TnyAccount * tny_account = NULL;
+						/* Add the account: */
+						tny_account = modest_tny_account_new_from_server_account_name (
+							priv->account_mgr, transport_account_name);
+						if (tny_account) {
+							g_object_set_data (G_OBJECT(tny_account), "account_store",
+									   (gpointer)self);
+							if (list)
+								tny_list_prepend (list, G_OBJECT(tny_account));
+							
+							accounts = g_slist_append (accounts, tny_account); /* cache it */		
+						} else
+							g_printerr ("modest: failed to create smtp-specific account for %s\n",
+								    transport_account_name);
+					}
+				}
+				
+				iter = g_slist_next (iter);
+			}
+			
+			iter_account_names = g_slist_next (iter_account_names);
+		}		
+	}
+	
+	g_slist_free (account_names);
+	account_names = NULL;
+	
+	/* TODO: Delete the strings in the GSList */
+	
+	
+	/* We also create a per-account local outbox folder (a _store_ account) 
+	 * for each _transport_ account. */
+	if (type == TNY_ACCOUNT_TYPE_TRANSPORT) {
+		/* Now would be a good time to create the per-account local outbox folder 
+		 * _store_ accounts corresponding to each transport account: */
+		if (!priv->store_accounts_outboxes) {
+			create_per_account_local_outbox_folders	(self);
+		}
+	}
+	
+	/* But we only return the per-account local outbox folder when 
+	 * _store_ accounts are requested. */
+	if (type == TNY_ACCOUNT_TYPE_STORE) {
+		/* Create them if necessary, 
+		 * (which also requires creating the transport accounts, 
+		 * if necessary.) */
+		if (!priv->store_accounts_outboxes) {
+			create_per_account_local_outbox_folders	(self);
+		}
+	
+		/* Add them to the TnyList: */
+		if (priv->store_accounts_outboxes) {
+			GSList *iter = NULL;
+			for (iter = priv->store_accounts_outboxes; iter; iter = g_slist_next (iter)) {
+				TnyAccount *outbox_account = (TnyAccount*)iter->data;
+				if (list && outbox_account)
+					tny_list_prepend (list,  G_OBJECT(outbox_account));
+					
+				accounts = g_slist_append (accounts, outbox_account);
+			}
+		}
+	}
+		
+	if (type == TNY_ACCOUNT_TYPE_STORE) {
+			/* Store the cache: */
+			priv->store_accounts = accounts;
+	} else if (type == TNY_ACCOUNT_TYPE_TRANSPORT) {
+			/* Store the cache: */
+			priv->transport_accounts = accounts;
+	}
 }	
 
 
@@ -558,15 +709,13 @@ modest_tny_account_store_get_accounts  (TnyAccountStore *self, TnyList *list,
 	
 	if (request_type == TNY_ACCOUNT_STORE_STORE_ACCOUNTS)  {
 		if (!priv->store_accounts)
-			priv->store_accounts =
-				get_server_accounts (self, list, TNY_ACCOUNT_TYPE_STORE);
+			get_server_accounts (self, list, TNY_ACCOUNT_TYPE_STORE);
 		else
 			get_cached_accounts (self, list, TNY_ACCOUNT_TYPE_STORE);
 		
 	} else if (request_type == TNY_ACCOUNT_STORE_TRANSPORT_ACCOUNTS) {
 		if (!priv->transport_accounts)
-			priv->transport_accounts =
-				get_server_accounts (self, list, TNY_ACCOUNT_TYPE_TRANSPORT);
+			get_server_accounts (self, list, TNY_ACCOUNT_TYPE_TRANSPORT);
 		else
 			get_cached_accounts (self, list, TNY_ACCOUNT_TYPE_TRANSPORT);
 	} else
@@ -733,7 +882,7 @@ modest_tny_account_store_alert (TnyAccountStore *self, TnyAlertType type,
 	g_free (prompt);
 
 
-	printf("DEBUG: %s: returning %d\n", __FUNCTION__, retval);
+	/* printf("DEBUG: %s: returning %d\n", __FUNCTION__, retval); */
 	return retval;
 }
 
@@ -817,8 +966,7 @@ modest_tny_account_store_get_tny_account_by_account (ModestTnyAccountStore *self
 						     TnyAccountType type)
 {
 	TnyAccount *account = NULL;
-	ModestAccountData *account_data;
-	const gchar *id = NULL;
+	gchar *id = NULL;
 	ModestTnyAccountStorePrivate *priv;	
 
 	g_return_val_if_fail (self, NULL);
@@ -827,17 +975,27 @@ modest_tny_account_store_get_tny_account_by_account (ModestTnyAccountStore *self
 			      NULL);
 	
 	priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
-	
-	account_data = modest_account_mgr_get_account_data (priv->account_mgr, account_name);
-	if (!account_data) {
-		g_printerr ("modest: cannot get account data for account '%s'\n", account_name);
-		return NULL;
-	}
 
-	if (type == TNY_ACCOUNT_TYPE_STORE && account_data->store_account)
-		id = account_data->store_account->account_name;
-	else if (account_data->transport_account)
-		id = account_data->transport_account->account_name;
+	/* Special case for the local account */
+	if (!strcmp (account_name, MODEST_ACTUAL_LOCAL_FOLDERS_ACCOUNT_ID) && 
+	    type == TNY_ACCOUNT_TYPE_STORE) {
+		id = g_strdup (MODEST_ACTUAL_LOCAL_FOLDERS_ACCOUNT_ID);
+	} else {
+		ModestAccountData *account_data;
+
+		account_data = modest_account_mgr_get_account_data (priv->account_mgr, account_name);
+		if (!account_data) {
+			g_printerr ("modest: %s: cannot get account data for account '%s'\n", __FUNCTION__, account_name);
+			return NULL;
+		}
+
+		if (type == TNY_ACCOUNT_TYPE_STORE && account_data->store_account)
+			id = g_strdup (account_data->store_account->account_name);
+		else if (account_data->transport_account)
+			id = g_strdup (account_data->transport_account->account_name);
+
+		modest_account_mgr_free_account_data (priv->account_mgr, account_data);
+	}
 
 	if (!id)
 		g_printerr ("modest: could not get an id for account %s\n",
@@ -850,7 +1008,6 @@ modest_tny_account_store_get_tny_account_by_account (ModestTnyAccountStore *self
 			    type == TNY_ACCOUNT_TYPE_STORE? "store" : "transport",
 			    account_name, id ? id : "<none>");
 
-	modest_account_mgr_free_account_data (priv->account_mgr, account_data);
 	return account;	
 }
 
@@ -868,6 +1025,7 @@ get_smtp_specific_transport_account_for_open_connection (ModestTnyAccountStore *
 	g_assert (TNY_IS_MAEMO_CONIC_DEVICE (device));
 	TnyMaemoConicDevice *maemo_device = TNY_MAEMO_CONIC_DEVICE (device);	
 	const gchar* iap_id = tny_maemo_conic_device_get_current_iap_id (maemo_device);
+	/* printf ("DEBUG: %s: iap_id=%s\n", __FUNCTION__, iap_id); */
 	if (!iap_id)
 		return NULL;
 		
@@ -876,6 +1034,7 @@ get_smtp_specific_transport_account_for_open_connection (ModestTnyAccountStore *
 		return NULL;
 		
 	const gchar *connection_name = con_ic_iap_get_name (connection);
+	/* printf ("DEBUG: %s: connection_name=%s\n", __FUNCTION__, connection_name); */
 	if (!connection_name)
 		return NULL;
 	
@@ -883,11 +1042,15 @@ get_smtp_specific_transport_account_for_open_connection (ModestTnyAccountStore *
 	ModestAccountMgr *account_manager = modest_runtime_get_account_mgr ();
 	gchar* server_account_name = modest_account_mgr_get_connection_specific_smtp (account_manager, 
 		account_name, connection_name);
-		
-	if (!server_account_name)
+
+	/* printf ("DEBUG: %s: server_account_name=%s\n", __FUNCTION__, server_account_name); */
+	if (!server_account_name) {
 		return NULL; /* No connection-specific SMTP server was specified for this connection. */
+	}
 		
 	TnyAccount* account = modest_tny_account_store_get_tny_account_by_id (self, server_account_name);
+
+	/* printf ("DEBUG: %s: account=%p\n", __FUNCTION__, account); */
 	g_free (server_account_name);	
 
 	/* Unref the get()ed object, as required by the tny_maemo_conic_device_get_iap() documentation. */
@@ -909,10 +1072,18 @@ modest_tny_account_store_get_transport_account_for_open_connection (ModestTnyAcc
 			
 	/* If there is no connection-specific transport account (the common case), 
 	 * just get the regular transport account: */
-	if (!account) {		
+	if (!account) {
+		/* printf("DEBUG: %s: using regular transport account for account %s.\n", __FUNCTION__, account_name); */
 		account = modest_tny_account_store_get_tny_account_by_account (self, account_name, 
 						     TNY_ACCOUNT_TYPE_TRANSPORT);
 	}
 			     
 	return account;
 }
+
+gboolean modest_tny_folder_store_is_virtual_local_folders (TnyFolderStore *self)
+{
+	/* We should make this more sophisticated if we ever use ModestTnySimpleFolderStore 
+	 * for anything else. */
+	return MODEST_IS_TNY_SIMPLE_FOLDER_STORE (self);
+}