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);
213 g_return_if_fail(msg_id != NULL);
215 /* Put newly added message in WAITING state */
216 existing = modest_tny_send_queue_lookup_info (MODEST_TNY_SEND_QUEUE(self), msg_id);
217 if(existing != NULL) {
218 info = existing->data;
219 info->status = MODEST_TNY_SEND_QUEUE_WAITING;
221 info = g_slice_new (SendInfo);
222 info->msg_id = msg_id;
223 info->status = MODEST_TNY_SEND_QUEUE_WAITING;
224 g_queue_push_tail (priv->queue, info);
227 g_signal_emit (self, signals[STATUS_CHANGED_SIGNAL], 0, info->msg_id, info->status);
229 g_object_unref(G_OBJECT(header));
233 _add_message (ModestTnySendQueue *self, TnyHeader *header)
235 ModestWindowMgr *mgr = NULL;
236 ModestTnySendQueuePrivate *priv;
237 SendInfo *info = NULL;
238 GList* existing = NULL;
239 gchar* msg_uid = NULL;
240 ModestTnySendQueueStatus status = MODEST_TNY_SEND_QUEUE_UNKNOWN;
241 gboolean editing = FALSE;
243 g_return_if_fail (TNY_IS_SEND_QUEUE(self));
244 g_return_if_fail (TNY_IS_HEADER(header));
245 priv = MODEST_TNY_SEND_QUEUE_GET_PRIVATE (self);
247 /* Check whether the mail is already in the queue */
248 msg_uid = modest_tny_send_queue_get_msg_id (header);
249 status = modest_tny_send_queue_get_msg_status (self, msg_uid);
251 case MODEST_TNY_SEND_QUEUE_UNKNOWN:
252 case MODEST_TNY_SEND_QUEUE_SUSPENDED:
253 case MODEST_TNY_SEND_QUEUE_FAILED:
255 /* Check if it already exists on queue */
256 existing = modest_tny_send_queue_lookup_info (MODEST_TNY_SEND_QUEUE(self), msg_uid);
260 /* Check if its being edited */
261 mgr = modest_runtime_get_window_mgr ();
262 editing = modest_window_mgr_find_registered_header (mgr, header, NULL);
266 /* Add new meesage info */
267 info = g_slice_new (SendInfo);
268 info->msg_id = strdup(msg_uid);
269 info->status = MODEST_TNY_SEND_QUEUE_WAITING;
270 g_queue_push_tail (priv->queue, info);
281 modest_tny_send_queue_add_async (TnySendQueue *self,
283 TnySendQueueAddCallback callback,
284 TnyStatusCallback status_callback,
287 /* Call the superclass passing our own callback */
288 TNY_CAMEL_SEND_QUEUE_CLASS(parent_class)->add_async (self, msg, _on_added_to_outbox, NULL, NULL);
293 modest_tny_send_queue_get_sentbox (TnySendQueue *self)
295 ModestTnySendQueuePrivate *priv;
297 g_return_val_if_fail (self, NULL);
299 priv = MODEST_TNY_SEND_QUEUE_GET_PRIVATE (self);
301 return g_object_ref (priv->sentbox);
306 modest_tny_send_queue_get_outbox (TnySendQueue *self)
308 ModestTnySendQueuePrivate *priv;
310 g_return_val_if_fail (self, NULL);
312 priv = MODEST_TNY_SEND_QUEUE_GET_PRIVATE (self);
314 return g_object_ref (priv->outbox);
318 modest_tny_send_queue_get_type (void)
320 static GType my_type = 0;
323 static const GTypeInfo my_info = {
324 sizeof(ModestTnySendQueueClass),
325 NULL, /* base init */
326 NULL, /* base finalize */
327 (GClassInitFunc) modest_tny_send_queue_class_init,
328 NULL, /* class finalize */
329 NULL, /* class data */
330 sizeof(ModestTnySendQueue),
332 (GInstanceInitFunc) modest_tny_send_queue_instance_init,
336 my_type = g_type_register_static (TNY_TYPE_CAMEL_SEND_QUEUE,
337 "ModestTnySendQueue",
345 modest_tny_send_queue_class_init (ModestTnySendQueueClass *klass)
347 GObjectClass *gobject_class;
349 gobject_class = (GObjectClass*) klass;
351 parent_class = g_type_class_peek_parent (klass);
352 gobject_class->finalize = modest_tny_send_queue_finalize;
354 TNY_CAMEL_SEND_QUEUE_CLASS(klass)->add_async = modest_tny_send_queue_add_async;
355 TNY_CAMEL_SEND_QUEUE_CLASS(klass)->get_outbox = modest_tny_send_queue_get_outbox;
356 TNY_CAMEL_SEND_QUEUE_CLASS(klass)->get_sentbox = modest_tny_send_queue_get_sentbox;
357 klass->status_changed = NULL;
359 signals[STATUS_CHANGED_SIGNAL] =
360 g_signal_new ("status_changed",
361 G_TYPE_FROM_CLASS (gobject_class),
363 G_STRUCT_OFFSET (ModestTnySendQueueClass, status_changed),
365 modest_marshal_VOID__STRING_INT,
366 G_TYPE_NONE, 2, G_TYPE_STRING, G_TYPE_INT);
368 g_type_class_add_private (gobject_class, sizeof(ModestTnySendQueuePrivate));
372 modest_tny_send_queue_instance_init (GTypeInstance *instance, gpointer g_class)
374 ModestTnySendQueuePrivate *priv;
376 priv = MODEST_TNY_SEND_QUEUE_GET_PRIVATE (instance);
377 priv->queue = g_queue_new();
378 priv->current = NULL;
382 modest_tny_send_queue_finalize (GObject *obj)
384 ModestTnySendQueuePrivate *priv;
386 priv = MODEST_TNY_SEND_QUEUE_GET_PRIVATE (obj);
388 g_queue_foreach (priv->queue, (GFunc)modest_tny_send_queue_info_free, NULL);
389 g_queue_free (priv->queue);
391 g_object_unref (priv->outbox);
392 g_object_unref (priv->sentbox);
394 G_OBJECT_CLASS(parent_class)->finalize (obj);
398 modest_tny_send_queue_new (TnyCamelTransportAccount *account)
400 ModestTnySendQueue *self = NULL;
401 ModestTnySendQueuePrivate *priv = NULL;
402 TnyIterator *iter = NULL;
403 TnyList *headers = NULL;
405 g_return_val_if_fail (TNY_IS_CAMEL_TRANSPORT_ACCOUNT(account), NULL);
407 self = MODEST_TNY_SEND_QUEUE(g_object_new(MODEST_TYPE_TNY_SEND_QUEUE, NULL));
409 /* Connect signals to control when a msg is being or has been sent */
410 g_signal_connect (G_OBJECT(self), "msg-sending",
411 G_CALLBACK(_on_msg_start_sending),
413 g_signal_connect (G_OBJECT(self), "msg-sent",
414 G_CALLBACK(_on_msg_has_been_sent),
416 g_signal_connect (G_OBJECT(self), "error-happened",
417 G_CALLBACK(_on_msg_error_happened),
419 g_signal_connect (G_OBJECT (self), "queue-start",
420 G_CALLBACK (_on_queue_start),
423 /* Set outbox and sentbox */
424 priv = MODEST_TNY_SEND_QUEUE_GET_PRIVATE (self);
425 priv->outbox = modest_tny_account_get_special_folder (TNY_ACCOUNT(account),
426 TNY_FOLDER_TYPE_OUTBOX);
427 priv->sentbox = modest_tny_account_get_special_folder (TNY_ACCOUNT(account),
428 TNY_FOLDER_TYPE_SENT);
430 priv->requested_send_receive = FALSE;
433 headers = tny_simple_list_new ();
434 tny_folder_get_headers (priv->outbox, headers, TRUE, NULL);
436 /* Add messages to our internal queue */
437 iter = tny_list_create_iterator (headers);
438 while (!tny_iterator_is_done (iter)) {
439 TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter));
440 _add_message (self, header);
441 g_object_unref (header);
443 tny_iterator_next (iter);
446 /* Reenable suspended items */
447 modest_tny_send_queue_wakeup (self);
450 g_object_unref (headers);
451 g_object_unref (iter);
453 /* Do this at the end, because it'll call tny_send_queue_flush
454 which will call tny_send_queue_get_outbox and
455 tny_send_queue_get_sentbox */
456 tny_camel_send_queue_set_transport_account (TNY_CAMEL_SEND_QUEUE(self),
463 modest_tny_send_queue_msg_is_being_sent (ModestTnySendQueue* self,
466 ModestTnySendQueueStatus status;
468 g_return_val_if_fail (msg_id != NULL, FALSE);
470 status = modest_tny_send_queue_get_msg_status (self, msg_id);
471 return status == MODEST_TNY_SEND_QUEUE_SENDING;
475 modest_tny_send_queue_sending_in_progress (ModestTnySendQueue* self)
477 ModestTnySendQueuePrivate *priv;
479 g_return_val_if_fail (MODEST_IS_TNY_SEND_QUEUE(self), FALSE);
481 priv = MODEST_TNY_SEND_QUEUE_GET_PRIVATE (self);
483 return priv->current != NULL;
486 ModestTnySendQueueStatus
487 modest_tny_send_queue_get_msg_status (ModestTnySendQueue *self, const gchar *msg_id)
491 g_return_val_if_fail (MODEST_IS_TNY_SEND_QUEUE(self), MODEST_TNY_SEND_QUEUE_UNKNOWN);
492 g_return_val_if_fail (msg_id, MODEST_TNY_SEND_QUEUE_UNKNOWN);
494 item = modest_tny_send_queue_lookup_info (self, msg_id);
496 return MODEST_TNY_SEND_QUEUE_UNKNOWN;
498 return ((SendInfo*)item->data)->status;
502 modest_tny_send_queue_get_msg_id (TnyHeader *header)
504 gchar* msg_uid = NULL;
505 const gchar *subject;
506 time_t date_received;
508 g_return_val_if_fail (header && TNY_IS_HEADER(header), NULL);
510 /* Get message uid */
511 subject = tny_header_get_subject (header);
512 date_received = tny_header_get_date_received (header);
514 msg_uid = g_strdup_printf ("%s %d", subject, (int) date_received);
521 _on_msg_start_sending (TnySendQueue *self, TnyHeader *header,
522 TnyMsg *msg, int done, int total, gpointer user_data)
524 ModestTnySendQueuePrivate *priv = NULL;
526 SendInfo *info = NULL;
527 gchar *msg_id = NULL;
529 priv = MODEST_TNY_SEND_QUEUE_GET_PRIVATE (self);
531 /* Get message uid */
532 msg_id = modest_tny_send_queue_get_msg_id (header);
534 item = modest_tny_send_queue_lookup_info (MODEST_TNY_SEND_QUEUE (self), msg_id);
536 g_warning ("%s: could not get msg-id for header", __FUNCTION__);
539 /* Set current status item */
541 info->status = MODEST_TNY_SEND_QUEUE_SENDING;
542 g_signal_emit (self, signals[STATUS_CHANGED_SIGNAL], 0, info->msg_id, info->status);
543 priv->current = item;
545 g_warning ("%s: could not find item with id '%s'", __FUNCTION__, msg_id);
552 _on_msg_has_been_sent (TnySendQueue *self,
559 ModestTnySendQueuePrivate *priv;
560 gchar *msg_id = NULL;
563 priv = MODEST_TNY_SEND_QUEUE_GET_PRIVATE (self);
565 /* Get message uid */
566 msg_id = modest_tny_send_queue_get_msg_id (header);
568 tny_header_set_flag (header, TNY_HEADER_FLAG_SEEN);
570 /* Get status info */
571 item = modest_tny_send_queue_lookup_info (MODEST_TNY_SEND_QUEUE (self), msg_id);
574 /* TODO: note that item=NULL must not happen, but I found that
575 tinymail is issuing the message-sent signal twice, because
576 tny_camel_send_queue_update is called twice for each
577 message sent. This must be fixed in tinymail. Sergio */
579 /* Remove status info */
580 modest_tny_send_queue_info_free (item->data);
581 g_queue_delete_link (priv->queue, item);
582 priv->current = NULL;
584 modest_platform_information_banner (NULL, NULL, _("mcen_ib_message_sent"));
592 _on_msg_error_happened (TnySendQueue *self,
598 ModestTnySendQueuePrivate *priv = NULL;
600 priv = MODEST_TNY_SEND_QUEUE_GET_PRIVATE (self);
602 /* Note that header could be NULL. Tinymail notifies about
603 generic send queue errors with this signal as well, and
604 those notifications are not bound to any particular header
607 SendInfo *info = NULL;
609 gchar* msg_uid = NULL;
611 /* Get sending info (create new if it doesn not exist) */
612 msg_uid = modest_tny_send_queue_get_msg_id (header);
613 item = modest_tny_send_queue_lookup_info (MODEST_TNY_SEND_QUEUE (self),
618 /* Keep in queue so that we remember that the opertion has failed */
619 /* and was not just cancelled */
620 if (err->code == TNY_SYSTEM_ERROR_CANCEL)
621 info->status = MODEST_TNY_SEND_QUEUE_SUSPENDED;
623 info->status = MODEST_TNY_SEND_QUEUE_FAILED;
624 priv->current = NULL;
626 /* Notify status has changed */
627 g_signal_emit (self, signals[STATUS_CHANGED_SIGNAL], 0, info->msg_id, info->status);
635 _on_queue_start (TnySendQueue *self,
638 ModestMailOperation *mail_op;
640 mail_op = modest_mail_operation_new (NULL);
641 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
643 modest_mail_operation_run_queue (mail_op, MODEST_TNY_SEND_QUEUE (self));
644 g_object_unref (mail_op);
648 fill_list_of_caches (gpointer key, gpointer value, gpointer userdata)
650 GSList **send_queues = (GSList **) userdata;
651 *send_queues = g_slist_prepend (*send_queues, value);
654 /* This function shouldn't be here. Move it to another place. Sergio */
655 ModestTnySendQueueStatus
656 modest_tny_all_send_queues_get_msg_status (TnyHeader *header)
658 ModestCacheMgr *cache_mgr = NULL;
659 GHashTable *send_queue_cache = NULL;
660 ModestTnyAccountStore *accounts_store = NULL;
661 TnyList *accounts = NULL;
662 TnyIterator *iter = NULL;
663 TnyTransportAccount *account = NULL;
664 GSList *send_queues = NULL, *node;
665 /* get_msg_status returns suspended by default, so we want to detect changes */
666 ModestTnySendQueueStatus status = MODEST_TNY_SEND_QUEUE_UNKNOWN;
667 ModestTnySendQueueStatus queue_status = MODEST_TNY_SEND_QUEUE_UNKNOWN;
668 gchar *msg_uid = NULL;
669 ModestTnySendQueue *send_queue = NULL;
671 g_return_val_if_fail (TNY_IS_HEADER(header), MODEST_TNY_SEND_QUEUE_UNKNOWN);
673 msg_uid = modest_tny_send_queue_get_msg_id (header);
674 cache_mgr = modest_runtime_get_cache_mgr ();
675 send_queue_cache = modest_cache_mgr_get_cache (cache_mgr,
676 MODEST_CACHE_MGR_CACHE_TYPE_SEND_QUEUE);
678 g_hash_table_foreach (send_queue_cache, (GHFunc) fill_list_of_caches, &send_queues);
679 if (send_queues == NULL) {
680 accounts = tny_simple_list_new ();
681 accounts_store = modest_runtime_get_account_store ();
682 tny_account_store_get_accounts (TNY_ACCOUNT_STORE(accounts_store),
684 TNY_ACCOUNT_STORE_TRANSPORT_ACCOUNTS);
686 iter = tny_list_create_iterator (accounts);
687 while (!tny_iterator_is_done (iter)) {
688 account = TNY_TRANSPORT_ACCOUNT(tny_iterator_get_current (iter));
689 send_queue = modest_runtime_get_send_queue(TNY_TRANSPORT_ACCOUNT(account));
690 g_object_unref(account);
692 queue_status = modest_tny_send_queue_get_msg_status (send_queue, msg_uid);
693 if (queue_status != MODEST_TNY_SEND_QUEUE_UNKNOWN) {
694 status = queue_status;
697 tny_iterator_next (iter);
699 g_object_unref (iter);
700 g_object_unref (accounts);
703 for (node = send_queues; node != NULL; node = g_slist_next (node)) {
704 send_queue = MODEST_TNY_SEND_QUEUE (node->data);
706 queue_status = modest_tny_send_queue_get_msg_status (send_queue, msg_uid);
707 if (queue_status != MODEST_TNY_SEND_QUEUE_UNKNOWN) {
708 status = queue_status;
715 g_slist_free (send_queues);
720 modest_tny_send_queue_wakeup (ModestTnySendQueue *self)
722 ModestTnySendQueuePrivate *priv;
726 g_return_if_fail (MODEST_IS_TNY_SEND_QUEUE (self));
728 priv = MODEST_TNY_SEND_QUEUE_GET_PRIVATE (self);
730 headers = tny_simple_list_new ();
731 tny_folder_get_headers (priv->outbox, headers, TRUE, NULL);
733 /* Wake up every single suspended header */
734 iter = tny_list_create_iterator (headers);
735 while (!tny_iterator_is_done (iter)) {
736 TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter));
738 if (tny_header_get_flags (header) & TNY_HEADER_FLAG_SUSPENDED) {
743 /* Unset the suspended flag */
744 tny_header_unset_flag (header, TNY_HEADER_FLAG_SUSPENDED);
747 msg_id = modest_tny_send_queue_get_msg_id (header);
748 item = modest_tny_send_queue_lookup_info (MODEST_TNY_SEND_QUEUE (self), msg_id);
749 info = (SendInfo *) item->data;
750 info->status = MODEST_TNY_SEND_QUEUE_WAITING;
751 g_signal_emit (self, signals[STATUS_CHANGED_SIGNAL], 0, info->msg_id, info->status);
758 g_object_unref (header);
759 tny_iterator_next (iter);
762 /* Make changes persistent on disk */
763 tny_folder_sync_async (priv->outbox, FALSE, NULL, NULL, NULL);
766 g_object_unref (iter);
767 g_object_unref (G_OBJECT (headers));
771 modest_tny_send_queue_get_requested_send_receive (ModestTnySendQueue *self)
773 ModestTnySendQueuePrivate *priv;
775 g_return_val_if_fail (MODEST_IS_TNY_SEND_QUEUE (self), FALSE);
776 priv = MODEST_TNY_SEND_QUEUE_GET_PRIVATE (self);
778 return priv->requested_send_receive;
782 modest_tny_send_queue_set_requested_send_receive (ModestTnySendQueue *self, gboolean requested_send_receive)
784 ModestTnySendQueuePrivate *priv;
786 g_return_if_fail (MODEST_IS_TNY_SEND_QUEUE (self));
787 priv = MODEST_TNY_SEND_QUEUE_GET_PRIVATE (self);
789 priv->requested_send_receive = requested_send_receive;