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-tny-send-queue.h>
32 #include <tny-simple-list.h>
33 #include <tny-iterator.h>
34 #include <tny-folder.h>
35 #include <tny-error.h>
36 #include <tny-camel-msg.h>
37 #include <tny-folder-change.h>
38 #include <tny-folder-observer.h>
39 #include <modest-tny-account.h>
40 #include <modest-runtime.h>
41 #include <modest-platform.h>
42 #include <widgets/modest-window-mgr.h>
43 #include <modest-marshal.h>
44 #include <modest-debug.h>
45 #include <string.h> /* strcmp */
47 /* 'private'/'protected' functions */
48 static void modest_tny_send_queue_class_init (ModestTnySendQueueClass *klass);
49 static void modest_tny_send_queue_finalize (GObject *obj);
50 static void modest_tny_send_queue_instance_init (GTypeInstance *instance, gpointer g_class);
53 static void _on_msg_start_sending (TnySendQueue *self,
60 static void _on_msg_has_been_sent (TnySendQueue *self,
67 static void _on_msg_error_happened (TnySendQueue *self,
73 static void _on_queue_start (TnySendQueue *self,
76 static void modest_tny_send_queue_add_async (TnySendQueue *self,
78 TnySendQueueAddCallback callback,
79 TnyStatusCallback status_callback,
82 static TnyFolder* modest_tny_send_queue_get_outbox (TnySendQueue *self);
83 static TnyFolder* modest_tny_send_queue_get_sentbox (TnySendQueue *self);
87 STATUS_CHANGED_SIGNAL,
91 typedef struct _SendInfo SendInfo;
94 ModestTnySendQueueStatus status;
97 typedef struct _ModestTnySendQueuePrivate ModestTnySendQueuePrivate;
98 struct _ModestTnySendQueuePrivate {
102 /* The info that is currently being sent */
105 /* Special folders */
109 /* last was send receive operation?*/
110 gboolean requested_send_receive;
113 #define MODEST_TNY_SEND_QUEUE_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE((o), \
114 MODEST_TYPE_TNY_SEND_QUEUE, \
115 ModestTnySendQueuePrivate))
118 static TnyCamelSendQueueClass *parent_class = NULL;
120 /* uncomment the following if you have defined any signals */
121 static guint signals[LAST_SIGNAL] = {0};
124 * this thread actually tries to send all the mails in the outbox and keeps
125 * track of their state.
129 on_modest_tny_send_queue_compare_id (gconstpointer info, gconstpointer msg_id)
131 g_return_val_if_fail (info && ((SendInfo*)info)->msg_id && msg_id, -1);
133 return strcmp( ((SendInfo*)info)->msg_id, msg_id);
137 modest_tny_send_queue_info_free (SendInfo *info)
139 g_free(info->msg_id);
140 g_slice_free(SendInfo, info);
144 modest_tny_send_queue_lookup_info (ModestTnySendQueue *self, const gchar *msg_id)
146 ModestTnySendQueuePrivate *priv;
147 priv = MODEST_TNY_SEND_QUEUE_GET_PRIVATE (self);
149 return g_queue_find_custom (priv->queue, msg_id, on_modest_tny_send_queue_compare_id);
154 queue_item_to_string (gpointer data, gchar **user_data)
156 SendInfo *info = (SendInfo*)data;
160 if (!(user_data && *user_data))
163 switch (info->status) {
164 case MODEST_TNY_SEND_QUEUE_UNKNOWN: status = "UNKNOWN"; break;
165 case MODEST_TNY_SEND_QUEUE_WAITING: status = "WAITING"; break;
166 case MODEST_TNY_SEND_QUEUE_SUSPENDED: status = "SUSPENDED"; break;
167 case MODEST_TNY_SEND_QUEUE_SENDING: status = "SENDING"; break;
168 case MODEST_TNY_SEND_QUEUE_FAILED: status = "FAILED"; break;
169 default: status= "UNEXPECTED"; break;
172 tmp = g_strdup_printf ("%s\"%s\" => [%s]\n",
173 *user_data, info->msg_id, status);
179 modest_tny_send_queue_to_string (ModestTnySendQueue *self)
182 ModestTnySendQueuePrivate *priv;
184 g_return_val_if_fail (MODEST_IS_TNY_SEND_QUEUE(self), NULL);
185 priv = MODEST_TNY_SEND_QUEUE_GET_PRIVATE (self);
187 str = g_strdup_printf ("items in the send queue: %d\n",
188 g_queue_get_length (priv->queue));
190 g_queue_foreach (priv->queue, (GFunc)queue_item_to_string, &str);
196 _on_added_to_outbox (TnySendQueue *self,
202 ModestTnySendQueuePrivate *priv = MODEST_TNY_SEND_QUEUE_GET_PRIVATE(self);
203 TnyHeader *header = NULL;
204 SendInfo *info = NULL;
205 GList* existing = NULL;
206 gchar* msg_id = NULL;
208 g_return_if_fail (TNY_IS_SEND_QUEUE(self));
209 g_return_if_fail (TNY_IS_CAMEL_MSG(msg));
211 header = tny_msg_get_header (msg);
212 msg_id = modest_tny_send_queue_get_msg_id (header);
214 g_warning ("%s: No msg_id returned for header", __FUNCTION__);
218 /* Put newly added message in WAITING state */
219 existing = modest_tny_send_queue_lookup_info (MODEST_TNY_SEND_QUEUE(self), msg_id);
220 if(existing != NULL) {
221 info = existing->data;
222 info->status = MODEST_TNY_SEND_QUEUE_WAITING;
224 info = g_slice_new (SendInfo);
225 info->msg_id = msg_id;
226 info->status = MODEST_TNY_SEND_QUEUE_WAITING;
227 g_queue_push_tail (priv->queue, info);
230 g_signal_emit (self, signals[STATUS_CHANGED_SIGNAL], 0, info->msg_id, info->status);
233 g_object_unref (G_OBJECT(header));
237 _add_message (ModestTnySendQueue *self, TnyHeader *header)
239 ModestWindowMgr *mgr = NULL;
240 ModestTnySendQueuePrivate *priv;
241 SendInfo *info = NULL;
242 GList* existing = NULL;
243 gchar* msg_uid = NULL;
244 ModestTnySendQueueStatus status = MODEST_TNY_SEND_QUEUE_UNKNOWN;
245 gboolean editing = FALSE;
247 g_return_if_fail (TNY_IS_SEND_QUEUE(self));
248 g_return_if_fail (TNY_IS_HEADER(header));
249 priv = MODEST_TNY_SEND_QUEUE_GET_PRIVATE (self);
251 /* Check whether the mail is already in the queue */
252 msg_uid = modest_tny_send_queue_get_msg_id (header);
253 status = modest_tny_send_queue_get_msg_status (self, msg_uid);
255 case MODEST_TNY_SEND_QUEUE_UNKNOWN:
256 case MODEST_TNY_SEND_QUEUE_SUSPENDED:
257 case MODEST_TNY_SEND_QUEUE_FAILED:
259 /* Check if it already exists on queue */
260 existing = modest_tny_send_queue_lookup_info (MODEST_TNY_SEND_QUEUE(self), msg_uid);
264 /* Check if its being edited */
265 mgr = modest_runtime_get_window_mgr ();
266 editing = modest_window_mgr_find_registered_header (mgr, header, NULL);
270 /* Add new meesage info */
271 info = g_slice_new (SendInfo);
272 info->msg_id = strdup(msg_uid);
273 info->status = MODEST_TNY_SEND_QUEUE_WAITING;
274 g_queue_push_tail (priv->queue, info);
285 modest_tny_send_queue_add_async (TnySendQueue *self,
287 TnySendQueueAddCallback callback,
288 TnyStatusCallback status_callback,
291 /* Call the superclass passing our own callback */
292 TNY_CAMEL_SEND_QUEUE_CLASS(parent_class)->add_async (self, msg, _on_added_to_outbox, NULL, NULL);
297 modest_tny_send_queue_get_sentbox (TnySendQueue *self)
299 ModestTnySendQueuePrivate *priv;
301 g_return_val_if_fail (self, NULL);
303 priv = MODEST_TNY_SEND_QUEUE_GET_PRIVATE (self);
305 return g_object_ref (priv->sentbox);
310 modest_tny_send_queue_get_outbox (TnySendQueue *self)
312 ModestTnySendQueuePrivate *priv;
314 g_return_val_if_fail (self, NULL);
316 priv = MODEST_TNY_SEND_QUEUE_GET_PRIVATE (self);
318 return g_object_ref (priv->outbox);
322 modest_tny_send_queue_get_type (void)
324 static GType my_type = 0;
327 static const GTypeInfo my_info = {
328 sizeof(ModestTnySendQueueClass),
329 NULL, /* base init */
330 NULL, /* base finalize */
331 (GClassInitFunc) modest_tny_send_queue_class_init,
332 NULL, /* class finalize */
333 NULL, /* class data */
334 sizeof(ModestTnySendQueue),
336 (GInstanceInitFunc) modest_tny_send_queue_instance_init,
340 my_type = g_type_register_static (TNY_TYPE_CAMEL_SEND_QUEUE,
341 "ModestTnySendQueue",
349 modest_tny_send_queue_class_init (ModestTnySendQueueClass *klass)
351 GObjectClass *gobject_class;
353 gobject_class = (GObjectClass*) klass;
355 parent_class = g_type_class_peek_parent (klass);
356 gobject_class->finalize = modest_tny_send_queue_finalize;
358 TNY_CAMEL_SEND_QUEUE_CLASS(klass)->add_async = modest_tny_send_queue_add_async;
359 TNY_CAMEL_SEND_QUEUE_CLASS(klass)->get_outbox = modest_tny_send_queue_get_outbox;
360 TNY_CAMEL_SEND_QUEUE_CLASS(klass)->get_sentbox = modest_tny_send_queue_get_sentbox;
361 klass->status_changed = NULL;
363 signals[STATUS_CHANGED_SIGNAL] =
364 g_signal_new ("status_changed",
365 G_TYPE_FROM_CLASS (gobject_class),
367 G_STRUCT_OFFSET (ModestTnySendQueueClass, status_changed),
369 modest_marshal_VOID__STRING_INT,
370 G_TYPE_NONE, 2, G_TYPE_STRING, G_TYPE_INT);
372 g_type_class_add_private (gobject_class, sizeof(ModestTnySendQueuePrivate));
376 modest_tny_send_queue_instance_init (GTypeInstance *instance, gpointer g_class)
378 ModestTnySendQueuePrivate *priv;
380 priv = MODEST_TNY_SEND_QUEUE_GET_PRIVATE (instance);
381 priv->queue = g_queue_new();
382 priv->current = NULL;
386 modest_tny_send_queue_finalize (GObject *obj)
388 ModestTnySendQueuePrivate *priv;
390 priv = MODEST_TNY_SEND_QUEUE_GET_PRIVATE (obj);
392 g_queue_foreach (priv->queue, (GFunc)modest_tny_send_queue_info_free, NULL);
393 g_queue_free (priv->queue);
395 g_object_unref (priv->outbox);
396 g_object_unref (priv->sentbox);
398 G_OBJECT_CLASS(parent_class)->finalize (obj);
402 modest_tny_send_queue_new (TnyCamelTransportAccount *account)
404 ModestTnySendQueue *self = NULL;
405 ModestTnySendQueuePrivate *priv = NULL;
406 TnyIterator *iter = NULL;
407 TnyList *headers = NULL;
409 g_return_val_if_fail (TNY_IS_CAMEL_TRANSPORT_ACCOUNT(account), NULL);
411 self = MODEST_TNY_SEND_QUEUE(g_object_new(MODEST_TYPE_TNY_SEND_QUEUE, NULL));
413 /* Connect signals to control when a msg is being or has been sent */
414 g_signal_connect (G_OBJECT(self), "msg-sending",
415 G_CALLBACK(_on_msg_start_sending),
417 g_signal_connect (G_OBJECT(self), "msg-sent",
418 G_CALLBACK(_on_msg_has_been_sent),
420 g_signal_connect (G_OBJECT(self), "error-happened",
421 G_CALLBACK(_on_msg_error_happened),
423 g_signal_connect (G_OBJECT (self), "queue-start",
424 G_CALLBACK (_on_queue_start),
427 /* Set outbox and sentbox */
428 priv = MODEST_TNY_SEND_QUEUE_GET_PRIVATE (self);
429 priv->outbox = modest_tny_account_get_special_folder (TNY_ACCOUNT(account),
430 TNY_FOLDER_TYPE_OUTBOX);
431 priv->sentbox = modest_tny_account_get_special_folder (TNY_ACCOUNT(account),
432 TNY_FOLDER_TYPE_SENT);
434 priv->requested_send_receive = FALSE;
437 headers = tny_simple_list_new ();
438 tny_folder_get_headers (priv->outbox, headers, TRUE, NULL);
440 /* Add messages to our internal queue */
441 iter = tny_list_create_iterator (headers);
442 while (!tny_iterator_is_done (iter)) {
443 TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter));
444 _add_message (self, header);
445 g_object_unref (header);
447 tny_iterator_next (iter);
450 /* Reenable suspended items */
451 modest_tny_send_queue_wakeup (self);
454 g_object_unref (headers);
455 g_object_unref (iter);
457 /* Do this at the end, because it'll call tny_send_queue_flush
458 which will call tny_send_queue_get_outbox and
459 tny_send_queue_get_sentbox */
460 tny_camel_send_queue_set_transport_account (TNY_CAMEL_SEND_QUEUE(self),
467 modest_tny_send_queue_msg_is_being_sent (ModestTnySendQueue* self,
470 ModestTnySendQueueStatus status;
472 g_return_val_if_fail (msg_id != NULL, FALSE);
474 status = modest_tny_send_queue_get_msg_status (self, msg_id);
475 return status == MODEST_TNY_SEND_QUEUE_SENDING;
479 modest_tny_send_queue_sending_in_progress (ModestTnySendQueue* self)
481 ModestTnySendQueuePrivate *priv;
483 g_return_val_if_fail (MODEST_IS_TNY_SEND_QUEUE(self), FALSE);
485 priv = MODEST_TNY_SEND_QUEUE_GET_PRIVATE (self);
487 return priv->current != NULL;
490 ModestTnySendQueueStatus
491 modest_tny_send_queue_get_msg_status (ModestTnySendQueue *self, const gchar *msg_id)
495 g_return_val_if_fail (MODEST_IS_TNY_SEND_QUEUE(self), MODEST_TNY_SEND_QUEUE_UNKNOWN);
496 g_return_val_if_fail (msg_id, MODEST_TNY_SEND_QUEUE_UNKNOWN);
498 item = modest_tny_send_queue_lookup_info (self, msg_id);
500 return MODEST_TNY_SEND_QUEUE_UNKNOWN;
502 return ((SendInfo*)item->data)->status;
506 modest_tny_send_queue_get_msg_id (TnyHeader *header)
508 gchar* msg_uid = NULL;
510 time_t date_received;
512 g_return_val_if_fail (header && TNY_IS_HEADER(header), NULL);
514 /* Get message uid */
515 subject = tny_header_dup_subject (header);
516 date_received = tny_header_get_date_received (header);
518 msg_uid = g_strdup_printf ("%s %d", subject, (int) date_received);
526 _on_msg_start_sending (TnySendQueue *self, TnyHeader *header,
527 TnyMsg *msg, int done, int total, gpointer user_data)
529 ModestTnySendQueuePrivate *priv = NULL;
531 SendInfo *info = NULL;
532 gchar *msg_id = NULL;
534 priv = MODEST_TNY_SEND_QUEUE_GET_PRIVATE (self);
536 /* Get message uid */
537 msg_id = modest_tny_send_queue_get_msg_id (header);
539 item = modest_tny_send_queue_lookup_info (MODEST_TNY_SEND_QUEUE (self), msg_id);
541 g_warning ("%s: could not get msg-id for header", __FUNCTION__);
544 /* Set current status item */
546 info->status = MODEST_TNY_SEND_QUEUE_SENDING;
547 g_signal_emit (self, signals[STATUS_CHANGED_SIGNAL], 0, info->msg_id, info->status);
548 priv->current = item;
550 g_warning ("%s: could not find item with id '%s'", __FUNCTION__, msg_id);
557 _on_msg_has_been_sent (TnySendQueue *self,
564 ModestTnySendQueuePrivate *priv;
565 gchar *msg_id = NULL;
568 priv = MODEST_TNY_SEND_QUEUE_GET_PRIVATE (self);
570 /* Get message uid */
571 msg_id = modest_tny_send_queue_get_msg_id (header);
573 tny_header_set_flag (header, TNY_HEADER_FLAG_SEEN);
575 tny_folder_sync_async (priv->sentbox, FALSE, NULL, NULL, NULL);
577 /* Get status info */
578 item = modest_tny_send_queue_lookup_info (MODEST_TNY_SEND_QUEUE (self), msg_id);
581 /* TODO: note that item=NULL must not happen, but I found that
582 tinymail is issuing the message-sent signal twice, because
583 tny_camel_send_queue_update is called twice for each
584 message sent. This must be fixed in tinymail. Sergio */
586 /* Remove status info */
587 modest_tny_send_queue_info_free (item->data);
588 g_queue_delete_link (priv->queue, item);
589 priv->current = NULL;
591 modest_platform_information_banner (NULL, NULL, _("mcen_ib_message_sent"));
599 _on_msg_error_happened (TnySendQueue *self,
605 ModestTnySendQueuePrivate *priv = NULL;
607 priv = MODEST_TNY_SEND_QUEUE_GET_PRIVATE (self);
609 /* Note that header could be NULL. Tinymail notifies about
610 generic send queue errors with this signal as well, and
611 those notifications are not bound to any particular header
613 if (header && TNY_IS_HEADER (header)) {
614 SendInfo *info = NULL;
616 gchar* msg_uid = NULL;
618 /* Get sending info (create new if it doesn not exist) */
619 msg_uid = modest_tny_send_queue_get_msg_id (header);
620 item = modest_tny_send_queue_lookup_info (MODEST_TNY_SEND_QUEUE (self),
623 /* TODO: this should not happen (but it does), so the
624 problem should be located in the way we generate
627 g_warning ("%s: could not find item with id '%s'", __FUNCTION__, msg_uid);
634 /* Keep in queue so that we remember that the opertion has failed */
635 /* and was not just cancelled */
636 if (err->code == TNY_SYSTEM_ERROR_CANCEL)
637 info->status = MODEST_TNY_SEND_QUEUE_SUSPENDED;
639 info->status = MODEST_TNY_SEND_QUEUE_FAILED;
640 priv->current = NULL;
642 /* Notify status has changed */
643 g_signal_emit (self, signals[STATUS_CHANGED_SIGNAL], 0, info->msg_id, info->status);
651 _on_queue_start (TnySendQueue *self,
654 ModestMailOperation *mail_op;
656 mail_op = modest_mail_operation_new (NULL);
657 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
659 modest_mail_operation_run_queue (mail_op, MODEST_TNY_SEND_QUEUE (self));
660 g_object_unref (mail_op);
664 fill_list_of_caches (gpointer key, gpointer value, gpointer userdata)
666 GSList **send_queues = (GSList **) userdata;
667 *send_queues = g_slist_prepend (*send_queues, value);
670 /* This function shouldn't be here. Move it to another place. Sergio */
671 ModestTnySendQueueStatus
672 modest_tny_all_send_queues_get_msg_status (TnyHeader *header)
674 ModestCacheMgr *cache_mgr = NULL;
675 GHashTable *send_queue_cache = NULL;
676 ModestTnyAccountStore *accounts_store = NULL;
677 TnyList *accounts = NULL;
678 TnyIterator *iter = NULL;
679 TnyTransportAccount *account = NULL;
680 GSList *send_queues = NULL, *node;
681 /* get_msg_status returns suspended by default, so we want to detect changes */
682 ModestTnySendQueueStatus status = MODEST_TNY_SEND_QUEUE_UNKNOWN;
683 ModestTnySendQueueStatus queue_status = MODEST_TNY_SEND_QUEUE_UNKNOWN;
684 gchar *msg_uid = NULL;
685 ModestTnySendQueue *send_queue = NULL;
687 g_return_val_if_fail (TNY_IS_HEADER(header), MODEST_TNY_SEND_QUEUE_UNKNOWN);
689 msg_uid = modest_tny_send_queue_get_msg_id (header);
690 cache_mgr = modest_runtime_get_cache_mgr ();
691 send_queue_cache = modest_cache_mgr_get_cache (cache_mgr,
692 MODEST_CACHE_MGR_CACHE_TYPE_SEND_QUEUE);
694 g_hash_table_foreach (send_queue_cache, (GHFunc) fill_list_of_caches, &send_queues);
695 if (send_queues == NULL) {
696 accounts = tny_simple_list_new ();
697 accounts_store = modest_runtime_get_account_store ();
698 tny_account_store_get_accounts (TNY_ACCOUNT_STORE(accounts_store),
700 TNY_ACCOUNT_STORE_TRANSPORT_ACCOUNTS);
702 iter = tny_list_create_iterator (accounts);
703 while (!tny_iterator_is_done (iter)) {
704 account = TNY_TRANSPORT_ACCOUNT(tny_iterator_get_current (iter));
705 send_queue = modest_runtime_get_send_queue(TNY_TRANSPORT_ACCOUNT(account), TRUE);
706 g_object_unref(account);
708 queue_status = modest_tny_send_queue_get_msg_status (send_queue, msg_uid);
709 if (queue_status != MODEST_TNY_SEND_QUEUE_UNKNOWN) {
710 status = queue_status;
713 tny_iterator_next (iter);
715 g_object_unref (iter);
716 g_object_unref (accounts);
719 for (node = send_queues; node != NULL; node = g_slist_next (node)) {
720 send_queue = MODEST_TNY_SEND_QUEUE (node->data);
722 queue_status = modest_tny_send_queue_get_msg_status (send_queue, msg_uid);
723 if (queue_status != MODEST_TNY_SEND_QUEUE_UNKNOWN) {
724 status = queue_status;
731 g_slist_free (send_queues);
736 modest_tny_send_queue_wakeup (ModestTnySendQueue *self)
738 ModestTnySendQueuePrivate *priv;
742 g_return_if_fail (MODEST_IS_TNY_SEND_QUEUE (self));
744 priv = MODEST_TNY_SEND_QUEUE_GET_PRIVATE (self);
746 headers = tny_simple_list_new ();
747 tny_folder_get_headers (priv->outbox, headers, TRUE, NULL);
749 /* Wake up every single suspended header */
750 iter = tny_list_create_iterator (headers);
751 while (!tny_iterator_is_done (iter)) {
752 TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter));
754 if (tny_header_get_flags (header) & TNY_HEADER_FLAG_SUSPENDED) {
759 /* Unset the suspended flag */
760 tny_header_unset_flag (header, TNY_HEADER_FLAG_SUSPENDED);
763 msg_id = modest_tny_send_queue_get_msg_id (header);
764 item = modest_tny_send_queue_lookup_info (MODEST_TNY_SEND_QUEUE (self), msg_id);
765 info = (SendInfo *) item->data;
766 info->status = MODEST_TNY_SEND_QUEUE_WAITING;
767 g_signal_emit (self, signals[STATUS_CHANGED_SIGNAL], 0, info->msg_id, info->status);
774 g_object_unref (header);
775 tny_iterator_next (iter);
778 /* Make changes persistent on disk */
779 tny_folder_sync_async (priv->outbox, FALSE, NULL, NULL, NULL);
782 g_object_unref (iter);
783 g_object_unref (G_OBJECT (headers));
787 modest_tny_send_queue_get_requested_send_receive (ModestTnySendQueue *self)
789 ModestTnySendQueuePrivate *priv;
791 g_return_val_if_fail (MODEST_IS_TNY_SEND_QUEUE (self), FALSE);
792 priv = MODEST_TNY_SEND_QUEUE_GET_PRIVATE (self);
794 return priv->requested_send_receive;
798 modest_tny_send_queue_set_requested_send_receive (ModestTnySendQueue *self, gboolean requested_send_receive)
800 ModestTnySendQueuePrivate *priv;
802 g_return_if_fail (MODEST_IS_TNY_SEND_QUEUE (self));
803 priv = MODEST_TNY_SEND_QUEUE_GET_PRIVATE (self);
805 priv->requested_send_receive = requested_send_receive;