X-Git-Url: http://git.maemo.org/git/?p=modest;a=blobdiff_plain;f=src%2Fmodest-tny-send-queue.c;h=62c75c678ccaaa4bfefd9f9a715c16a006e8ebe0;hp=b1f8560eb00e31bc843a9627dd4eb0bfdf48d7a8;hb=027bd4e81f906263a15a732d2707b1fcec630872;hpb=6dff75fc6a5d9515c03abb45d2f000b9eeacfbd4

diff --git a/src/modest-tny-send-queue.c b/src/modest-tny-send-queue.c
index b1f8560..62c75c6 100644
--- a/src/modest-tny-send-queue.c
+++ b/src/modest-tny-send-queue.c
@@ -73,7 +73,10 @@ static void _on_msg_error_happened (TnySendQueue *self,
 static void _on_queue_start        (TnySendQueue *self, 
 				    gpointer user_data);
 
-static void modest_tny_send_queue_add_async (TnyCamelSendQueue *self, 
+static void _on_queue_stop         (TnySendQueue *self,
+				    gpointer data);
+
+static void modest_tny_send_queue_add_async (TnySendQueue *self, 
 					     TnyMsg *msg, 
 					     TnySendQueueAddCallback callback, 
 					     TnyStatusCallback status_callback, 
@@ -105,6 +108,11 @@ struct _ModestTnySendQueuePrivate {
 	/* Special folders */
 	TnyFolder *outbox;
 	TnyFolder *sentbox;
+
+	/* last was send receive operation?*/
+	gboolean requested_send_receive;
+
+	gboolean sending;
 };
 
 #define MODEST_TNY_SEND_QUEUE_GET_PRIVATE(o)      (G_TYPE_INSTANCE_GET_PRIVATE((o), \
@@ -189,6 +197,11 @@ modest_tny_send_queue_to_string (ModestTnySendQueue *self)
 	return str;
 }
 
+typedef struct {
+	TnySendQueueAddCallback callback;
+	gpointer user_data;
+} AddAsyncHelper;
+
 static void
 _on_added_to_outbox (TnySendQueue *self, 
 		     gboolean cancelled, 
@@ -201,13 +214,17 @@ _on_added_to_outbox (TnySendQueue *self,
 	SendInfo *info = NULL;
 	GList* existing = NULL;
 	gchar* msg_id = NULL;
+	AddAsyncHelper *helper;
 
 	g_return_if_fail (TNY_IS_SEND_QUEUE(self));
 	g_return_if_fail (TNY_IS_CAMEL_MSG(msg));
 
 	header = tny_msg_get_header (msg);
 	msg_id = modest_tny_send_queue_get_msg_id (header);
-	g_return_if_fail(msg_id != NULL);
+	if (!msg_id) {
+		g_warning ("%s: No msg_id returned for header", __FUNCTION__);
+		goto end;
+	}
 
 	/* Put newly added message in WAITING state */
 	existing = modest_tny_send_queue_lookup_info (MODEST_TNY_SEND_QUEUE(self), msg_id);
@@ -223,7 +240,14 @@ _on_added_to_outbox (TnySendQueue *self,
 
 	g_signal_emit (self, signals[STATUS_CHANGED_SIGNAL], 0, info->msg_id, info->status);
 
-	g_object_unref(G_OBJECT(header));
+ end:
+	g_object_unref (G_OBJECT(header));
+
+	/* Call the user callback */
+	helper = (AddAsyncHelper *) user_data;
+	if (helper->callback)
+		helper->callback (self, cancelled, msg, err, helper->user_data);
+	g_slice_free (AddAsyncHelper, helper);
 }
 
 static void
@@ -261,7 +285,7 @@ _add_message (ModestTnySendQueue *self, TnyHeader *header)
 			break;
 		
 		/* Add new meesage info */
-		info = g_slice_new (SendInfo);
+		info = g_slice_new0 (SendInfo);
 		info->msg_id = strdup(msg_uid);
 		info->status = MODEST_TNY_SEND_QUEUE_WAITING;
 		g_queue_push_tail (priv->queue, info);
@@ -275,14 +299,21 @@ _add_message (ModestTnySendQueue *self, TnyHeader *header)
 }
 
 static void 
-modest_tny_send_queue_add_async (TnyCamelSendQueue *self, 
+modest_tny_send_queue_add_async (TnySendQueue *self, 
 				 TnyMsg *msg, 
 				 TnySendQueueAddCallback callback, 
 				 TnyStatusCallback status_callback, 
 				 gpointer user_data)
 {
+	AddAsyncHelper *helper = g_slice_new0 (AddAsyncHelper);
+	helper->callback = callback;
+	helper->user_data = user_data;
+
 	/* Call the superclass passing our own callback */
-	TNY_CAMEL_SEND_QUEUE_CLASS(parent_class)->add_async_func (self, msg, _on_added_to_outbox, NULL, NULL);
+	TNY_CAMEL_SEND_QUEUE_CLASS(parent_class)->add_async (self, msg, 
+							     _on_added_to_outbox, 
+							     status_callback, 
+							     helper);
 }
 
 
@@ -348,9 +379,9 @@ modest_tny_send_queue_class_init (ModestTnySendQueueClass *klass)
 	parent_class            = g_type_class_peek_parent (klass);
 	gobject_class->finalize = modest_tny_send_queue_finalize;
 
-	TNY_CAMEL_SEND_QUEUE_CLASS(klass)->add_async_func  = modest_tny_send_queue_add_async;
-	TNY_CAMEL_SEND_QUEUE_CLASS(klass)->get_outbox_func  = modest_tny_send_queue_get_outbox;
-        TNY_CAMEL_SEND_QUEUE_CLASS(klass)->get_sentbox_func = modest_tny_send_queue_get_sentbox;
+	TNY_CAMEL_SEND_QUEUE_CLASS(klass)->add_async   = modest_tny_send_queue_add_async;
+	TNY_CAMEL_SEND_QUEUE_CLASS(klass)->get_outbox  = modest_tny_send_queue_get_outbox;
+        TNY_CAMEL_SEND_QUEUE_CLASS(klass)->get_sentbox = modest_tny_send_queue_get_sentbox;
 	klass->status_changed   = NULL;
 
 	signals[STATUS_CHANGED_SIGNAL] =
@@ -373,22 +404,80 @@ modest_tny_send_queue_instance_init (GTypeInstance *instance, gpointer g_class)
 	priv = MODEST_TNY_SEND_QUEUE_GET_PRIVATE (instance);
 	priv->queue = g_queue_new();
 	priv->current = NULL;
+	priv->outbox = NULL;
+	priv->sentbox = NULL;
+	priv->sending = FALSE;
 }
 
 static void
 modest_tny_send_queue_finalize (GObject *obj)
 {
 	ModestTnySendQueuePrivate *priv;
-		
+
 	priv = MODEST_TNY_SEND_QUEUE_GET_PRIVATE (obj);
 
 	g_queue_foreach (priv->queue, (GFunc)modest_tny_send_queue_info_free, NULL);
 	g_queue_free (priv->queue);
 
+	G_OBJECT_CLASS(parent_class)->finalize (obj);
 	g_object_unref (priv->outbox);
 	g_object_unref (priv->sentbox);
+}
 
-	G_OBJECT_CLASS(parent_class)->finalize (obj);
+typedef struct {
+	TnyCamelTransportAccount *account;
+	ModestTnySendQueue *queue;
+} GetHeadersInfo;
+
+static void
+new_queue_get_headers_async_cb (TnyFolder *folder, 
+				gboolean cancelled, 
+				TnyList *headers, 
+				GError *err, 
+				gpointer user_data)
+{
+	ModestTnySendQueue *self;
+	TnyIterator *iter;
+	GetHeadersInfo *info;
+	ModestMailOperation *wakeup_op;
+
+	info = (GetHeadersInfo *) user_data;
+	self = MODEST_TNY_SEND_QUEUE (info->queue);
+
+	/* In case of error set the transport account anyway */
+	if (cancelled || err)
+		goto set_transport;
+
+	/* Add messages to our internal queue */
+	iter = tny_list_create_iterator (headers);
+	while (!tny_iterator_is_done (iter)) {
+		TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter));
+		_add_message (self, header);
+		g_object_unref (header);	
+		tny_iterator_next (iter);
+	}
+
+	/* Reenable suspended items */
+	wakeup_op = modest_mail_operation_new (NULL);
+	modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
+					 wakeup_op);
+	modest_mail_operation_queue_wakeup (wakeup_op, MODEST_TNY_SEND_QUEUE (self));
+
+	/* Frees */
+	g_object_unref (iter);
+	g_object_unref (headers);
+
+ set_transport:
+	/* Do this at the end, because it'll call tny_send_queue_flush
+	   which will call tny_send_queue_get_outbox and
+	   tny_send_queue_get_sentbox */
+	tny_camel_send_queue_set_transport_account (TNY_CAMEL_SEND_QUEUE(self),
+						    info->account);
+
+	/* Frees */
+	g_object_unref (info->account); 
+	g_object_unref (info->queue); 
+	g_slice_free (GetHeadersInfo, info);
 }
 
 ModestTnySendQueue*
@@ -396,13 +485,27 @@ modest_tny_send_queue_new (TnyCamelTransportAccount *account)
 {
 	ModestTnySendQueue *self = NULL;
 	ModestTnySendQueuePrivate *priv = NULL;
-	TnyIterator *iter = NULL;
 	TnyList *headers = NULL;
+	GetHeadersInfo *info;
 	
 	g_return_val_if_fail (TNY_IS_CAMEL_TRANSPORT_ACCOUNT(account), NULL);
 	
 	self = MODEST_TNY_SEND_QUEUE(g_object_new(MODEST_TYPE_TNY_SEND_QUEUE, NULL));
-	
+
+	/* Set outbox and sentbox */
+	priv = MODEST_TNY_SEND_QUEUE_GET_PRIVATE (self);
+	priv->outbox  = modest_tny_account_get_special_folder (TNY_ACCOUNT(account),
+							       TNY_FOLDER_TYPE_OUTBOX);
+	priv->sentbox = modest_tny_account_get_special_folder (TNY_ACCOUNT(account),
+							       TNY_FOLDER_TYPE_SENT);
+
+	/* NOTE that this could happen if there was not enough disk
+	   space when the account was created */
+	if (!priv->outbox || !priv->sentbox) {
+		g_object_unref (self);
+		return NULL;
+	}
+
 	/* Connect signals to control when a msg is being or has been sent */
 	g_signal_connect (G_OBJECT(self), "msg-sending",
 			  G_CALLBACK(_on_msg_start_sending),
@@ -413,44 +516,24 @@ modest_tny_send_queue_new (TnyCamelTransportAccount *account)
 	g_signal_connect (G_OBJECT(self), "error-happened",
 	                  G_CALLBACK(_on_msg_error_happened),
 			  NULL);
+
 	g_signal_connect (G_OBJECT (self), "queue-start",
 			  G_CALLBACK (_on_queue_start),
 			  NULL);
 
-	/* Set outbox and sentbox */
-	priv = MODEST_TNY_SEND_QUEUE_GET_PRIVATE (self);
-	priv->outbox  = modest_tny_account_get_special_folder (TNY_ACCOUNT(account),
-							       TNY_FOLDER_TYPE_OUTBOX);
-	priv->sentbox = modest_tny_account_get_special_folder (TNY_ACCOUNT(account),
-							       TNY_FOLDER_TYPE_SENT);
-
-
-	headers = tny_simple_list_new ();	
-	tny_folder_get_headers (priv->outbox, headers, TRUE, NULL);
-
-	/* Add messages to our internal queue */
-	iter = tny_list_create_iterator (headers);
-	while (!tny_iterator_is_done (iter)) {
-		TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter));
-		_add_message (self, header); 
-		g_object_unref (header);		
-
-		tny_iterator_next (iter);
-	}
+	g_signal_connect (G_OBJECT (self), "queue-stop",
+			  G_CALLBACK (_on_queue_stop),
+			  NULL);
 
-	/* Reenable suspended items */
-	modest_tny_send_queue_wakeup (self);
+	priv->requested_send_receive = FALSE;
 
-	/* Frees */
-	g_object_unref (G_OBJECT (headers));
-	g_object_unref (G_OBJECT (priv->outbox));
-	g_object_unref (iter);
-
-	/* Do this at the end, because it'll call tny_send_queue_flush
-	   which will call tny_send_queue_get_outbox and
-	   tny_send_queue_get_sentbox */
-	tny_camel_send_queue_set_transport_account (TNY_CAMEL_SEND_QUEUE(self),
-						    account); 
+	headers = tny_simple_list_new ();
+	info = g_slice_new0 (GetHeadersInfo);
+	info->account = g_object_ref (account);
+	info->queue = g_object_ref (self);
+	tny_folder_get_headers_async (priv->outbox, headers, TRUE, 
+				      new_queue_get_headers_async_cb, 
+				      NULL, info);
 
 	return self;
 }
@@ -476,7 +559,7 @@ modest_tny_send_queue_sending_in_progress (ModestTnySendQueue* self)
 	
 	priv = MODEST_TNY_SEND_QUEUE_GET_PRIVATE (self);
 	
-	return priv->current != NULL;
+	return priv->sending;
 }
 
 ModestTnySendQueueStatus
@@ -498,28 +581,25 @@ gchar *
 modest_tny_send_queue_get_msg_id (TnyHeader *header)
 {
 	gchar* msg_uid = NULL;
-	const gchar *subject;
+	gchar *subject;
 	time_t date_received;
 		
 	g_return_val_if_fail (header && TNY_IS_HEADER(header), NULL);
 
 	/* Get message uid */
-	subject = tny_header_get_subject (header);
+	subject = tny_header_dup_subject (header);
 	date_received = tny_header_get_date_received (header);
 
 	msg_uid = g_strdup_printf ("%s %d", subject, (int) date_received);
+	g_free (subject);
 
 	return msg_uid;
 }
 
 
 static void
-_on_msg_start_sending (TnySendQueue *self,
-		       TnyHeader *header,
-		       TnyMsg *msg,
-		       int done, 
-		       int total,
-		       gpointer user_data)
+_on_msg_start_sending (TnySendQueue *self, TnyHeader *header,
+		       TnyMsg *msg, int done, int total, gpointer user_data)
 {
 	ModestTnySendQueuePrivate *priv = NULL;
 	GList *item = NULL;
@@ -530,16 +610,20 @@ _on_msg_start_sending (TnySendQueue *self,
 	
 	/* Get message uid */
 	msg_id = modest_tny_send_queue_get_msg_id (header);
-
-	/* Get status info */
-	item = modest_tny_send_queue_lookup_info (MODEST_TNY_SEND_QUEUE (self), msg_id);
-
-	/* Set current status item */
-	info = item->data;
-	info->status = MODEST_TNY_SEND_QUEUE_SENDING;
-	g_signal_emit (self, signals[STATUS_CHANGED_SIGNAL], 0, info->msg_id, info->status);
-	priv->current = item;
-
+	if (msg_id) 
+		item = modest_tny_send_queue_lookup_info (MODEST_TNY_SEND_QUEUE (self), msg_id);
+	else
+		g_warning ("%s: could not get msg-id for header", __FUNCTION__);
+	
+	if (item) {
+		/* Set current status item */
+		info = item->data;
+		info->status = MODEST_TNY_SEND_QUEUE_SENDING;
+		g_signal_emit (self, signals[STATUS_CHANGED_SIGNAL], 0, info->msg_id, info->status);
+		priv->current = item;
+	} else
+		g_warning ("%s: could not find item with id '%s'", __FUNCTION__, msg_id);
+	
 	/* free */
 	g_free (msg_id);
 }
@@ -563,6 +647,8 @@ _on_msg_has_been_sent (TnySendQueue *self,
 
 	tny_header_set_flag (header, TNY_HEADER_FLAG_SEEN);
 
+	tny_folder_sync_async (priv->sentbox, FALSE, NULL, NULL, NULL);
+
 	/* Get status info */
 	item = modest_tny_send_queue_lookup_info (MODEST_TNY_SEND_QUEUE (self), msg_id);
 
@@ -592,38 +678,83 @@ _on_msg_error_happened (TnySendQueue *self,
 			gpointer user_data)
 {
 	ModestTnySendQueuePrivate *priv = NULL;
-	SendInfo *info = NULL;
-	GList *item = NULL;
-	gchar* msg_uid = NULL;
 	
 	priv = MODEST_TNY_SEND_QUEUE_GET_PRIVATE (self);
-	
-	/* Get sending info (create new if it doesn not exist) */
-	msg_uid = modest_tny_send_queue_get_msg_id (header);
-	item = modest_tny_send_queue_lookup_info (MODEST_TNY_SEND_QUEUE (self), 
-						  msg_uid);	
 
-	info = item->data;
-
-	/* Keep in queue so that we remember that the opertion has failed */
-	/* and was not just cancelled */
-	if (err->code == TNY_SYSTEM_ERROR_CANCEL)
-		info->status = MODEST_TNY_SEND_QUEUE_SUSPENDED;
-	else
-		info->status = MODEST_TNY_SEND_QUEUE_FAILED;
-	priv->current = NULL;
-	
-	/* Notify status has changed */
-	g_signal_emit (self, signals[STATUS_CHANGED_SIGNAL], 0, info->msg_id, info->status);
+	/* Note that header could be NULL. Tinymail notifies about
+	   generic send queue errors with this signal as well, and
+	   those notifications are not bound to any particular header
+	   or message */
+	if (header && TNY_IS_HEADER (header)) {
+		SendInfo *info = NULL;
+		GList *item = NULL;
+		gchar* msg_uid = NULL;
+
+		/* Get sending info (create new if it doesn not exist) */
+		msg_uid = modest_tny_send_queue_get_msg_id (header);
+		item = modest_tny_send_queue_lookup_info (MODEST_TNY_SEND_QUEUE (self), 
+							  msg_uid);
+
+		/* TODO: this should not happen (but it does), so the
+		   problem should be located in the way we generate
+		   the message uids */
+		if (!item) {
+			g_warning ("%s: could not find item with id '%s'", __FUNCTION__, msg_uid);
+			g_free(msg_uid);
+			return;
+		}
+		
+		info = item->data;
+
+		/* Keep in queue so that we remember that the opertion has failed */
+		/* and was not just cancelled */
+		if (err->code == TNY_SYSTEM_ERROR_CANCEL) {
+			info->status = MODEST_TNY_SEND_QUEUE_SUSPENDED;
+		} else {
+			if (err->code == TNY_SERVICE_ERROR_CONNECT) {
+				TnyCamelTransportAccount* transport;
+				TnyTransportAccount *conn_specific;
+
+				transport = tny_camel_send_queue_get_transport_account (TNY_CAMEL_SEND_QUEUE (self));
+				if (transport) {
+					gchar *message;
+					ModestTnyAccountStore *acc_store;
+					const gchar *acc_name;
+
+					acc_store = modest_runtime_get_account_store();
+					acc_name = modest_tny_account_get_parent_modest_account_name_for_server_account (TNY_ACCOUNT (transport));
+					conn_specific = (TnyTransportAccount *)
+						modest_tny_account_store_get_transport_account_for_open_connection (acc_store, acc_name);
+					if (conn_specific) {
+						message = g_strdup_printf (_("emev_ib_ui_smtp_server_invalid"), 
+									   tny_account_get_hostname (TNY_ACCOUNT (conn_specific)));
+						g_object_unref (conn_specific);
+					} else {
+						message = g_strdup_printf (_("emev_ib_ui_smtp_server_invalid"), 
+									   tny_account_get_hostname (TNY_ACCOUNT (transport)));
+					}
+					modest_platform_run_alert_dialog (message, FALSE);
+					g_free (message);
+					g_object_unref (transport);
+				}
+			}
+			info->status = MODEST_TNY_SEND_QUEUE_FAILED;
+		}
+		priv->current = NULL;
+		
+		/* Notify status has changed */
+		g_signal_emit (self, signals[STATUS_CHANGED_SIGNAL], 0, info->msg_id, info->status);
 
-	/* free */
-	g_free(msg_uid);
+		/* free */
+		g_free(msg_uid);
+	}
 }
 
 static void 
 _on_queue_start (TnySendQueue *self,
 		 gpointer data)
 {
+	ModestTnySendQueuePrivate *priv;
 	ModestMailOperation *mail_op;
 
 	mail_op = modest_mail_operation_new (NULL);
@@ -631,6 +762,19 @@ _on_queue_start (TnySendQueue *self,
 					 mail_op);
 	modest_mail_operation_run_queue (mail_op, MODEST_TNY_SEND_QUEUE (self));
 	g_object_unref (mail_op);
+
+	priv = MODEST_TNY_SEND_QUEUE_GET_PRIVATE (self);
+	priv->sending = TRUE;
+}
+
+static void 
+_on_queue_stop (TnySendQueue *self,
+		gpointer data)
+{
+	ModestTnySendQueuePrivate *priv;
+
+	priv = MODEST_TNY_SEND_QUEUE_GET_PRIVATE (self);
+	priv->sending = FALSE;
 }
 
 static void 
@@ -675,13 +819,14 @@ modest_tny_all_send_queues_get_msg_status (TnyHeader *header)
 		iter = tny_list_create_iterator (accounts);
 		while (!tny_iterator_is_done (iter)) {			
 			account = TNY_TRANSPORT_ACCOUNT(tny_iterator_get_current (iter));
-			send_queue = modest_runtime_get_send_queue(TNY_TRANSPORT_ACCOUNT(account));
+			send_queue = modest_runtime_get_send_queue(TNY_TRANSPORT_ACCOUNT(account), TRUE);
 			g_object_unref(account);
-
-			queue_status = modest_tny_send_queue_get_msg_status (send_queue, msg_uid);
-			if (queue_status != MODEST_TNY_SEND_QUEUE_UNKNOWN) {
-				status = queue_status;
-				break;
+			if (TNY_IS_SEND_QUEUE (send_queue)) {
+				queue_status = modest_tny_send_queue_get_msg_status (send_queue, msg_uid);
+				if (queue_status != MODEST_TNY_SEND_QUEUE_UNKNOWN) {
+					status = queue_status;
+					break;
+				}
 			}
 			tny_iterator_next (iter);
 		}
@@ -705,19 +850,49 @@ modest_tny_all_send_queues_get_msg_status (TnyHeader *header)
 	return status;
 }
 
-void   
-modest_tny_send_queue_wakeup (ModestTnySendQueue *self)
+typedef struct _WakeupHelper {
+	ModestTnySendQueue *self;
+	ModestTnySendQueueWakeupFunc callback;
+	gpointer userdata;
+} WakeupHelper;
+
+static void
+wakeup_sync_cb (TnyFolder *self, gboolean cancelled, GError *err, gpointer userdata)
 {
+	WakeupHelper *helper = (WakeupHelper *) userdata;
+
+	if (helper->callback) {
+		helper->callback (helper->self, cancelled, err, helper->userdata);
+	}
+	g_object_unref (helper->self);
+	g_slice_free (WakeupHelper, helper);
+}
+
+static void
+wakeup_get_headers_async_cb (TnyFolder *folder, 
+			     gboolean cancelled, 
+			     TnyList *headers, 
+			     GError *err, 
+			     gpointer user_data)
+{
+	ModestTnySendQueue *self;
 	ModestTnySendQueuePrivate *priv;
-	TnyList *headers;
 	TnyIterator *iter;
+	WakeupHelper *helper = (WakeupHelper *) user_data;
 
-	g_return_if_fail (MODEST_IS_TNY_SEND_QUEUE (self));
-
+	self = MODEST_TNY_SEND_QUEUE (helper->self);
 	priv = MODEST_TNY_SEND_QUEUE_GET_PRIVATE (self);
 
-	headers = tny_simple_list_new ();
-	tny_folder_get_headers (priv->outbox, headers, TRUE, NULL);
+	if (cancelled || err) {
+		g_debug ("Failed to wake up the headers of the send queue");
+		g_object_unref (self);
+		if (helper->callback) {
+			helper->callback (helper->self, cancelled, err, helper->userdata);
+		}
+		g_object_unref (helper->self);
+		g_slice_free (WakeupHelper, helper);
+		return;
+	}
 
 	/* Wake up every single suspended header */
 	iter = tny_list_create_iterator (headers);
@@ -735,12 +910,16 @@ modest_tny_send_queue_wakeup (ModestTnySendQueue *self)
 			/* Notify view */
 			msg_id = modest_tny_send_queue_get_msg_id (header);			
 			item = modest_tny_send_queue_lookup_info (MODEST_TNY_SEND_QUEUE (self), msg_id);
-			info = (SendInfo *) item->data;
+			if (!item) {
+				info = g_slice_new (SendInfo);
+				info->msg_id = msg_id;
+				g_queue_push_tail (priv->queue, info);
+			} else {
+				info = (SendInfo *) item->data;
+				g_free (msg_id);
+			}
 			info->status = MODEST_TNY_SEND_QUEUE_WAITING;
-			g_signal_emit (self, signals[STATUS_CHANGED_SIGNAL], 0, info->msg_id, info->status);
-			
-			/* Frees */
-			g_free (msg_id);
+			g_signal_emit (self, signals[STATUS_CHANGED_SIGNAL], 0, info->msg_id, info->status);		
 		}
 
 		/* Frees */
@@ -748,7 +927,56 @@ modest_tny_send_queue_wakeup (ModestTnySendQueue *self)
 		tny_iterator_next (iter);
 	}
 
+	/* Make changes persistent on disk */
+	tny_folder_sync_async (priv->outbox, FALSE, wakeup_sync_cb, NULL, helper);
+
 	/* Frees */
 	g_object_unref (iter);
-	g_object_unref (G_OBJECT (headers));
+	g_object_unref (headers);
+	g_object_unref (self);
+}
+
+void   
+modest_tny_send_queue_wakeup (ModestTnySendQueue *self, 
+			      ModestTnySendQueueWakeupFunc callback,
+			      gpointer userdata)
+{
+	ModestTnySendQueuePrivate *priv;
+	TnyList *headers;
+	WakeupHelper *helper;
+
+	g_return_if_fail (MODEST_IS_TNY_SEND_QUEUE (self));
+	priv = MODEST_TNY_SEND_QUEUE_GET_PRIVATE (self);
+
+	helper = g_slice_new (WakeupHelper);
+	helper->self = g_object_ref (self);
+	helper->callback = callback;
+	helper->userdata = userdata;
+
+	headers = tny_simple_list_new ();
+	tny_folder_get_headers_async (priv->outbox, headers, TRUE, 
+				      wakeup_get_headers_async_cb, 
+				      NULL, helper);
+}
+
+gboolean 
+modest_tny_send_queue_get_requested_send_receive (ModestTnySendQueue *self)
+{
+	ModestTnySendQueuePrivate *priv;
+
+	g_return_val_if_fail (MODEST_IS_TNY_SEND_QUEUE (self), FALSE);
+	priv = MODEST_TNY_SEND_QUEUE_GET_PRIVATE (self);
+
+	return priv->requested_send_receive;
+}
+
+void 
+modest_tny_send_queue_set_requested_send_receive (ModestTnySendQueue *self, gboolean requested_send_receive)
+{
+	ModestTnySendQueuePrivate *priv;
+
+	g_return_if_fail (MODEST_IS_TNY_SEND_QUEUE (self));
+	priv = MODEST_TNY_SEND_QUEUE_GET_PRIVATE (self);
+
+	priv->requested_send_receive = requested_send_receive;
 }