X-Git-Url: http://git.maemo.org/git/?p=modest;a=blobdiff_plain;f=src%2Fmodest-tny-send-queue.c;h=480d4eaacb69a9b59effc6cf9617b83e1647aae3;hp=88bf044550e76b2a2eda479a7d6ba4cdc5617d71;hb=fc79bc0cc051e3b5654e85106c1ac150715e620c;hpb=14fe749887d662836e92b1faee19aa340b7c891c diff --git a/src/modest-tny-send-queue.c b/src/modest-tny-send-queue.c index 88bf044..480d4ea 100644 --- a/src/modest-tny-send-queue.c +++ b/src/modest-tny-send-queue.c @@ -32,6 +32,7 @@ #include #include #include +#include #include #include #include @@ -40,6 +41,7 @@ #include #include #include +#include #include /* strcmp */ /* 'private'/'protected' functions */ @@ -48,18 +50,41 @@ static void modest_tny_send_queue_finalize (GObject *obj); static void modest_tny_send_queue_instance_init (GTypeInstance *instance, gpointer g_class); /* Signal handlers */ -static void _on_msg_start_sending (TnySendQueue *self, TnyHeader *header, TnyMsg *msg, int done, int total, gpointer user_data); -static void _on_msg_has_been_sent (TnySendQueue *self, TnyHeader *header, TnyMsg *msg, int done, int total, gpointer user_data); -static void _on_msg_error_happened (TnySendQueue *self, TnyHeader *header, TnyMsg *msg, GError *err, gpointer user_data); - -static TnyFolder*modest_tny_send_queue_get_outbox (TnySendQueue *self); -static TnyFolder*modest_tny_send_queue_get_sentbox (TnySendQueue *self); +static void _on_msg_start_sending (TnySendQueue *self, + TnyHeader *header, + TnyMsg *msg, + int done, + int total, + gpointer user_data); + +static void _on_msg_has_been_sent (TnySendQueue *self, + TnyHeader *header, + TnyMsg *msg, + int done, + int total, + gpointer user_data); + +static void _on_msg_error_happened (TnySendQueue *self, + TnyHeader *header, + TnyMsg *msg, + GError *err, + gpointer user_data); + +static void _on_queue_start (TnySendQueue *self, + gpointer user_data); + +static void modest_tny_send_queue_add_async (TnySendQueue *self, + TnyMsg *msg, + TnySendQueueAddCallback callback, + TnyStatusCallback status_callback, + gpointer user_data); + +static TnyFolder* modest_tny_send_queue_get_outbox (TnySendQueue *self); +static TnyFolder* modest_tny_send_queue_get_sentbox (TnySendQueue *self); /* list my signals */ enum { - STATUS_CHANGED, - /* MY_SIGNAL_1, */ - /* MY_SIGNAL_2, */ + STATUS_CHANGED_SIGNAL, LAST_SIGNAL }; @@ -76,6 +101,10 @@ struct _ModestTnySendQueuePrivate { /* The info that is currently being sent */ GList* current; + + /* Special folders */ + TnyFolder *outbox; + TnyFolder *sentbox; }; #define MODEST_TNY_SEND_QUEUE_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE((o), \ @@ -94,7 +123,7 @@ static guint signals[LAST_SIGNAL] = {0}; */ static int -on_modest_tny_send_queue_compare_id(gconstpointer info, gconstpointer msg_id) +on_modest_tny_send_queue_compare_id (gconstpointer info, gconstpointer msg_id) { g_return_val_if_fail (info && ((SendInfo*)info)->msg_id && msg_id, -1); @@ -102,7 +131,7 @@ on_modest_tny_send_queue_compare_id(gconstpointer info, gconstpointer msg_id) } static void -modest_tny_send_queue_info_free(SendInfo *info) +modest_tny_send_queue_info_free (SendInfo *info) { g_free(info->msg_id); g_slice_free(SendInfo, info); @@ -113,108 +142,86 @@ modest_tny_send_queue_lookup_info (ModestTnySendQueue *self, const gchar *msg_id { ModestTnySendQueuePrivate *priv; priv = MODEST_TNY_SEND_QUEUE_GET_PRIVATE (self); - + return g_queue_find_custom (priv->queue, msg_id, on_modest_tny_send_queue_compare_id); } + static void -modest_tny_send_queue_cancel (TnySendQueue *self, gboolean remove, GError **err) +queue_item_to_string (gpointer data, gchar **user_data) +{ + SendInfo *info = (SendInfo*)data; + const gchar *status; + gchar *tmp; + + if (!(user_data && *user_data)) + return; + + switch (info->status) { + case MODEST_TNY_SEND_QUEUE_UNKNOWN: status = "UNKNOWN"; break; + case MODEST_TNY_SEND_QUEUE_WAITING: status = "WAITING"; break; + case MODEST_TNY_SEND_QUEUE_SUSPENDED: status = "SUSPENDED"; break; + case MODEST_TNY_SEND_QUEUE_SENDING: status = "SENDING"; break; + case MODEST_TNY_SEND_QUEUE_FAILED: status = "FAILED"; break; + default: status= "UNEXPECTED"; break; + } + + tmp = g_strdup_printf ("%s\"%s\" => [%s]\n", + *user_data, info->msg_id, status); + g_free (*user_data); + *user_data = tmp; +} + +gchar* +modest_tny_send_queue_to_string (ModestTnySendQueue *self) { + gchar *str; ModestTnySendQueuePrivate *priv; - SendInfo *info; - TnyIterator *iter = NULL; - TnyFolder *outbox = NULL; - TnyList *headers = tny_simple_list_new (); - TnyHeader *header = NULL; + g_return_val_if_fail (MODEST_IS_TNY_SEND_QUEUE(self), NULL); priv = MODEST_TNY_SEND_QUEUE_GET_PRIVATE (self); - if(priv->current != NULL) - { - info = priv->current->data; - priv->current = NULL; - /* Keep in list until retry, so that we know that this was suspended - * by the user and not by an error. */ - info->status = MODEST_TNY_SEND_QUEUE_SUSPENDED; - - g_signal_emit (self, signals[STATUS_CHANGED], 0, info->msg_id, info->status); - } + str = g_strdup_printf ("items in the send queue: %d\n", + g_queue_get_length (priv->queue)); + + g_queue_foreach (priv->queue, (GFunc)queue_item_to_string, &str); - /* Set flags to supend sending operaiton (if removed, this is not necessary) */ - if (!remove) { - outbox = modest_tny_send_queue_get_outbox (TNY_SEND_QUEUE(self)); - tny_folder_get_headers (outbox, headers, TRUE, err); - if (err != NULL) goto frees; - iter = tny_list_create_iterator (headers); - while (!tny_iterator_is_done (iter)) { - header = TNY_HEADER (tny_iterator_get_current (iter)); - if (header) { - tny_header_unset_flags (header, TNY_HEADER_FLAG_PRIORITY); - tny_header_set_flags (header, TNY_HEADER_FLAG_SUSPENDED_PRIORITY); - tny_iterator_next (iter); - g_object_unref (header); - } - } - - g_queue_foreach (priv->queue, (GFunc)modest_tny_send_queue_info_free, NULL); - g_queue_free (priv->queue); - priv->queue = g_queue_new(); - } - - /* Dont call super class implementaiton, becasue camel removes messages from outbox */ - TNY_CAMEL_SEND_QUEUE_CLASS(parent_class)->cancel_func (self, remove, err); /* FIXME */ - - frees: - if (headers != NULL) - g_object_unref (G_OBJECT (headers)); - if (outbox != NULL) - g_object_unref (G_OBJECT (outbox)); - if (iter != NULL) - g_object_unref (iter); + return str; } static void -modest_tny_send_queue_add (TnySendQueue *self, TnyMsg *msg, GError **err) +_on_added_to_outbox (TnySendQueue *self, + gboolean cancelled, + TnyMsg *msg, + GError *err, + gpointer user_data) { ModestTnySendQueuePrivate *priv = MODEST_TNY_SEND_QUEUE_GET_PRIVATE(self); TnyHeader *header = NULL; SendInfo *info = NULL; GList* existing = NULL; - const gchar* msg_id = NULL; + gchar* msg_id = NULL; g_return_if_fail (TNY_IS_SEND_QUEUE(self)); g_return_if_fail (TNY_IS_CAMEL_MSG(msg)); - TNY_CAMEL_SEND_QUEUE_CLASS(parent_class)->add_func (self, msg, err); /* FIXME */ - - /* TODO: We cannot access the message ID of the message here because - * it might just have been created. Wait for it being added to outbox. */ - header = tny_msg_get_header (msg); - msg_id = tny_header_get_message_id (header); + msg_id = modest_tny_send_queue_get_msg_id (header); g_return_if_fail(msg_id != NULL); /* Put newly added message in WAITING state */ existing = modest_tny_send_queue_lookup_info (MODEST_TNY_SEND_QUEUE(self), msg_id); - if(existing != NULL) - { - //g_assert(info->status == MODEST_TNY_SEND_QUEUE_SUSPENDED || - // info->status == MODEST_TNY_SEND_QUEUE_FAILED); - + if(existing != NULL) { info = existing->data; info->status = MODEST_TNY_SEND_QUEUE_WAITING; - } - else - { - + } else { info = g_slice_new (SendInfo); - - info->msg_id = strdup(msg_id); + info->msg_id = msg_id; info->status = MODEST_TNY_SEND_QUEUE_WAITING; g_queue_push_tail (priv->queue, info); } - g_signal_emit (self, signals[STATUS_CHANGED], 0, info->msg_id, info->status); + g_signal_emit (self, signals[STATUS_CHANGED_SIGNAL], 0, info->msg_id, info->status); g_object_unref(G_OBJECT(header)); } @@ -227,7 +234,7 @@ _add_message (ModestTnySendQueue *self, TnyHeader *header) SendInfo *info = NULL; GList* existing = NULL; gchar* msg_uid = NULL; - ModestTnySendQueueStatus status = MODEST_TNY_SEND_QUEUE_WAITING; + ModestTnySendQueueStatus status = MODEST_TNY_SEND_QUEUE_UNKNOWN; gboolean editing = FALSE; g_return_if_fail (TNY_IS_SEND_QUEUE(self)); @@ -238,12 +245,10 @@ _add_message (ModestTnySendQueue *self, TnyHeader *header) msg_uid = modest_tny_send_queue_get_msg_id (header); status = modest_tny_send_queue_get_msg_status (self, msg_uid); switch (status) { - case MODEST_TNY_SEND_QUEUE_UNKNONW: + case MODEST_TNY_SEND_QUEUE_UNKNOWN: case MODEST_TNY_SEND_QUEUE_SUSPENDED: case MODEST_TNY_SEND_QUEUE_FAILED: - if (status != MODEST_TNY_SEND_QUEUE_SUSPENDED) - tny_header_unset_flags (header, TNY_HEADER_FLAG_PRIORITY); - + /* Check if it already exists on queue */ existing = modest_tny_send_queue_lookup_info (MODEST_TNY_SEND_QUEUE(self), msg_uid); if(existing != NULL) @@ -269,51 +274,41 @@ _add_message (ModestTnySendQueue *self, TnyHeader *header) g_free(msg_uid); } +static void +modest_tny_send_queue_add_async (TnySendQueue *self, + TnyMsg *msg, + TnySendQueueAddCallback callback, + TnyStatusCallback status_callback, + gpointer user_data) +{ + /* Call the superclass passing our own callback */ + TNY_CAMEL_SEND_QUEUE_CLASS(parent_class)->add_async (self, msg, _on_added_to_outbox, NULL, NULL); +} + + static TnyFolder* modest_tny_send_queue_get_sentbox (TnySendQueue *self) { - TnyFolder *folder; - TnyCamelTransportAccount *account; + ModestTnySendQueuePrivate *priv; g_return_val_if_fail (self, NULL); - account = tny_camel_send_queue_get_transport_account (TNY_CAMEL_SEND_QUEUE(self)); - if (!account) { - g_printerr ("modest: no account for send queue\n"); - return NULL; - } - folder = modest_tny_account_get_special_folder (TNY_ACCOUNT(account), - TNY_FOLDER_TYPE_SENT); - g_object_unref (G_OBJECT(account)); + priv = MODEST_TNY_SEND_QUEUE_GET_PRIVATE (self); - return folder; + return g_object_ref (priv->sentbox); } static TnyFolder* modest_tny_send_queue_get_outbox (TnySendQueue *self) { - TnyFolder *folder; - TnyCamelTransportAccount *account; + ModestTnySendQueuePrivate *priv; g_return_val_if_fail (self, NULL); - account = tny_camel_send_queue_get_transport_account (TNY_CAMEL_SEND_QUEUE(self)); - if (!account) { - g_printerr ("modest: no account for send queue\n"); - return NULL; - } - folder = modest_tny_account_get_special_folder (TNY_ACCOUNT(account), - TNY_FOLDER_TYPE_OUTBOX); - - /* This vfunc's tinymail contract does not allow it to return NULL. */ - if (!folder) { - g_warning("%s: Returning NULL.\n", __FUNCTION__); - } - - g_object_unref (G_OBJECT(account)); + priv = MODEST_TNY_SEND_QUEUE_GET_PRIVATE (self); - return folder; + return g_object_ref (priv->outbox); } GType @@ -353,13 +348,12 @@ 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_func = modest_tny_send_queue_add; - 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)->cancel_func = modest_tny_send_queue_cancel; + 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] = + signals[STATUS_CHANGED_SIGNAL] = g_signal_new ("status_changed", G_TYPE_FROM_CLASS (gobject_class), G_SIGNAL_RUN_FIRST, @@ -391,21 +385,24 @@ modest_tny_send_queue_finalize (GObject *obj) g_queue_foreach (priv->queue, (GFunc)modest_tny_send_queue_info_free, NULL); g_queue_free (priv->queue); + g_object_unref (priv->outbox); + g_object_unref (priv->sentbox); + G_OBJECT_CLASS(parent_class)->finalize (obj); } ModestTnySendQueue* modest_tny_send_queue_new (TnyCamelTransportAccount *account) { - ModestTnySendQueue *self; + ModestTnySendQueue *self = NULL; + ModestTnySendQueuePrivate *priv = NULL; + TnyIterator *iter = NULL; + TnyList *headers = NULL; 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)); - tny_camel_send_queue_set_transport_account (TNY_CAMEL_SEND_QUEUE(self), - account); - /* 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), @@ -416,49 +413,45 @@ modest_tny_send_queue_new (TnyCamelTransportAccount *account) g_signal_connect (G_OBJECT(self), "error-happened", G_CALLBACK(_on_msg_error_happened), NULL); - return self; -} - - + g_signal_connect (G_OBJECT (self), "queue-start", + G_CALLBACK (_on_queue_start), + NULL); -void -modest_tny_send_queue_try_to_send (ModestTnySendQueue* self) -{ - TnyIterator *iter = NULL; - TnyFolder *outbox = NULL; - TnyList *headers = tny_simple_list_new (); - TnyHeader *header = NULL; - GError *err = 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); - outbox = modest_tny_send_queue_get_outbox (TNY_SEND_QUEUE(self)); - if (!outbox) - return; - tny_folder_get_headers (outbox, headers, TRUE, &err); - if (err != NULL) - goto frees; + 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)) { - header = TNY_HEADER (tny_iterator_get_current (iter)); - if (header) { - _add_message (self, header); - g_object_unref (header); - } + TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter)); + _add_message (self, header); + g_object_unref (header); tny_iterator_next (iter); } - - /* Flush send queue */ - tny_camel_send_queue_flush (TNY_CAMEL_SEND_QUEUE(self)); - - frees: - if (headers != NULL) - g_object_unref (G_OBJECT (headers)); - if (outbox != NULL) - g_object_unref (G_OBJECT (outbox)); - if (iter != NULL) - g_object_unref (iter); + + /* Reenable suspended items */ + modest_tny_send_queue_wakeup (self); + + /* Frees */ + g_object_unref (headers); + 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); + + return self; } gboolean @@ -477,6 +470,9 @@ gboolean modest_tny_send_queue_sending_in_progress (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->current != NULL; @@ -485,45 +481,40 @@ modest_tny_send_queue_sending_in_progress (ModestTnySendQueue* self) ModestTnySendQueueStatus modest_tny_send_queue_get_msg_status (ModestTnySendQueue *self, const gchar *msg_id) { - GList *item; - item = modest_tny_send_queue_lookup_info (self, msg_id); - if(item == NULL) return MODEST_TNY_SEND_QUEUE_UNKNONW; - return ((SendInfo*)item->data)->status; + GList *item; + + g_return_val_if_fail (MODEST_IS_TNY_SEND_QUEUE(self), MODEST_TNY_SEND_QUEUE_UNKNOWN); + g_return_val_if_fail (msg_id, MODEST_TNY_SEND_QUEUE_UNKNOWN); + + item = modest_tny_send_queue_lookup_info (self, msg_id); + if (!item) + return MODEST_TNY_SEND_QUEUE_UNKNOWN; + else + return ((SendInfo*)item->data)->status; } gchar * modest_tny_send_queue_get_msg_id (TnyHeader *header) { - const gchar *uid = NULL; gchar* msg_uid = NULL; - gchar **tmp = NULL; + const gchar *subject; + time_t date_received; + g_return_val_if_fail (header && TNY_IS_HEADER(header), NULL); + /* Get message uid */ - uid = tny_header_get_uid (header); - if (uid) - tmp = g_strsplit (uid, "__", 2); - - if (tmp) { - if (tmp[1] != NULL) - msg_uid = g_strconcat (tmp[0], "_", NULL); - else - msg_uid = g_strdup(tmp[0]); + subject = tny_header_get_subject (header); + date_received = tny_header_get_date_received (header); - /* free */ - g_strfreev(tmp); - } + msg_uid = g_strdup_printf ("%s %d", subject, (int) date_received); 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; @@ -534,20 +525,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); - if (!item) - g_warning ("%s: item should not be NULL", __FUNCTION__); - else { + 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; - - /* Set current status item */ - g_signal_emit (self, signals[STATUS_CHANGED], 0, info->msg_id, info->status); + 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); } @@ -561,20 +552,25 @@ _on_msg_has_been_sent (TnySendQueue *self, gpointer user_data) { ModestTnySendQueuePrivate *priv; - GList *item; gchar *msg_id = NULL; + GList *item; priv = MODEST_TNY_SEND_QUEUE_GET_PRIVATE (self); /* Get message uid */ msg_id = modest_tny_send_queue_get_msg_id (header); - + + tny_header_set_flag (header, TNY_HEADER_FLAG_SEEN); + /* Get status info */ item = modest_tny_send_queue_lookup_info (MODEST_TNY_SEND_QUEUE (self), msg_id); - if (!item) - g_warning ("%s: item should not be NULL", __FUNCTION__); - else { + + /* TODO: note that item=NULL must not happen, but I found that + tinymail is issuing the message-sent signal twice, because + tny_camel_send_queue_update is called twice for each + message sent. This must be fixed in tinymail. Sergio */ + if (item) { /* Remove status info */ modest_tny_send_queue_info_free (item->data); g_queue_delete_link (priv->queue, item); @@ -595,30 +591,173 @@ _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); - if (item == NULL) { - info = g_slice_new (SendInfo); - info->msg_id = strdup(msg_uid); - g_queue_push_tail (priv->queue, info); - } else - info = item->data; /* Keep in queue so that we remember that the opertion has failed */ /* and was not just cancelled */ - info->status = MODEST_TNY_SEND_QUEUE_FAILED; + 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; + + /* 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) { + 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); + + info = item->data; + + /* Notify status has changed */ + g_signal_emit (self, signals[STATUS_CHANGED_SIGNAL], 0, info->msg_id, info->status); + + /* free */ + g_free(msg_uid); + } +} + +static void +_on_queue_start (TnySendQueue *self, + gpointer data) +{ + ModestMailOperation *mail_op; + + mail_op = modest_mail_operation_new (NULL); + modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), + mail_op); + modest_mail_operation_run_queue (mail_op, MODEST_TNY_SEND_QUEUE (self)); + g_object_unref (mail_op); +} + +static void +fill_list_of_caches (gpointer key, gpointer value, gpointer userdata) +{ + GSList **send_queues = (GSList **) userdata; + *send_queues = g_slist_prepend (*send_queues, value); +} + +/* This function shouldn't be here. Move it to another place. Sergio */ +ModestTnySendQueueStatus +modest_tny_all_send_queues_get_msg_status (TnyHeader *header) +{ + ModestCacheMgr *cache_mgr = NULL; + GHashTable *send_queue_cache = NULL; + ModestTnyAccountStore *accounts_store = NULL; + TnyList *accounts = NULL; + TnyIterator *iter = NULL; + TnyTransportAccount *account = NULL; + GSList *send_queues = NULL, *node; + /* get_msg_status returns suspended by default, so we want to detect changes */ + ModestTnySendQueueStatus status = MODEST_TNY_SEND_QUEUE_UNKNOWN; + ModestTnySendQueueStatus queue_status = MODEST_TNY_SEND_QUEUE_UNKNOWN; + gchar *msg_uid = NULL; + ModestTnySendQueue *send_queue = NULL; - /* Notify status has changed */ - g_signal_emit (self, signals[STATUS_CHANGED], 0, info->msg_id, info->status); + g_return_val_if_fail (TNY_IS_HEADER(header), MODEST_TNY_SEND_QUEUE_UNKNOWN); + + msg_uid = modest_tny_send_queue_get_msg_id (header); + cache_mgr = modest_runtime_get_cache_mgr (); + send_queue_cache = modest_cache_mgr_get_cache (cache_mgr, + MODEST_CACHE_MGR_CACHE_TYPE_SEND_QUEUE); + + g_hash_table_foreach (send_queue_cache, (GHFunc) fill_list_of_caches, &send_queues); + if (send_queues == NULL) { + accounts = tny_simple_list_new (); + accounts_store = modest_runtime_get_account_store (); + tny_account_store_get_accounts (TNY_ACCOUNT_STORE(accounts_store), + accounts, + TNY_ACCOUNT_STORE_TRANSPORT_ACCOUNTS); + + 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)); + 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; + } + tny_iterator_next (iter); + } + g_object_unref (iter); + g_object_unref (accounts); + } + else { + for (node = send_queues; node != NULL; node = g_slist_next (node)) { + send_queue = MODEST_TNY_SEND_QUEUE (node->data); + + 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; + } + } + } - /* free */ g_free(msg_uid); + g_slist_free (send_queues); + return status; +} + +void +modest_tny_send_queue_wakeup (ModestTnySendQueue *self) +{ + ModestTnySendQueuePrivate *priv; + TnyList *headers; + TnyIterator *iter; + + g_return_if_fail (MODEST_IS_TNY_SEND_QUEUE (self)); + + priv = MODEST_TNY_SEND_QUEUE_GET_PRIVATE (self); + + headers = tny_simple_list_new (); + tny_folder_get_headers (priv->outbox, headers, TRUE, NULL); + + /* Wake up every single suspended header */ + iter = tny_list_create_iterator (headers); + while (!tny_iterator_is_done (iter)) { + TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter)); + + if (tny_header_get_flags (header) & TNY_HEADER_FLAG_SUSPENDED) { + gchar *msg_id; + GList *item; + SendInfo *info; + + /* Unset the suspended flag */ + tny_header_unset_flag (header, TNY_HEADER_FLAG_SUSPENDED); + + /* 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; + 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); + } + + /* Frees */ + g_object_unref (header); + tny_iterator_next (iter); + } + + /* Make changes persistent on disk */ + tny_folder_sync_async (priv->outbox, FALSE, NULL, NULL, NULL); + + /* Frees */ + g_object_unref (iter); + g_object_unref (G_OBJECT (headers)); }