X-Git-Url: http://git.maemo.org/git/?p=modest;a=blobdiff_plain;f=src%2Fmodest-tny-send-queue.c;h=281699cccdc07e8738191056c57439c8b0798d97;hp=6c92281803cd08cd02c1986c92eee92e3e619bb8;hb=362784ce756b3f0e31cd451d9ac5e69b909d4053;hpb=0cc78ab6510b62165262bb1bca8408c28a7dcb73 diff --git a/src/modest-tny-send-queue.c b/src/modest-tny-send-queue.c index 6c92281..281699c 100644 --- a/src/modest-tny-send-queue.c +++ b/src/modest-tny-send-queue.c @@ -29,119 +29,295 @@ #include +#include +#include +#include +#include +#include +#include +#include +#include +#include /* strcmp */ /* 'private'/'protected' functions */ static void modest_tny_send_queue_class_init (ModestTnySendQueueClass *klass); -static void modest_tny_send_queue_init (ModestTnySendQueue *obj); 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); + /* list my signals */ enum { + STATUS_CHANGED, /* MY_SIGNAL_1, */ /* MY_SIGNAL_2, */ LAST_SIGNAL }; +typedef struct _SendInfo SendInfo; +struct _SendInfo { + gchar* msg_id; + ModestTnySendQueueStatus status; +}; + typedef struct _ModestTnySendQueuePrivate ModestTnySendQueuePrivate; struct _ModestTnySendQueuePrivate { - TnyTransportAccount *account; - + /* Queued infos */ + GQueue* queue; + + /* The info that is currently being sent */ + GList* current; }; + #define MODEST_TNY_SEND_QUEUE_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE((o), \ MODEST_TYPE_TNY_SEND_QUEUE, \ ModestTnySendQueuePrivate)) + /* globals */ -static TnySendQueueClass *parent_class = NULL; +static TnyCamelSendQueueClass *parent_class = NULL; /* uncomment the following if you have defined any signals */ -/* static guint signals[LAST_SIGNAL] = {0}; */ +static guint signals[LAST_SIGNAL] = {0}; +/* + * this thread actually tries to send all the mails in the outbox and keeps + * track of their state. + */ -static void -modest_tny_send_queue_cancel (TnySendQueue *self, gboolean remove) +static int +on_modest_tny_send_queue_compare_id(gconstpointer info, gconstpointer msg_id) { - MODEST_TNY_SENT_QUEUE_GET_CLASS(self)->cancel_func (self, remove); + return strcmp( ((SendInfo*)info)->msg_id, msg_id); } static void -modest_tny_send_queue_add (TnySendQueue *self, TnyMsg *msg) +modest_tny_send_queue_info_free(SendInfo *info) { - MODEST_TNY_SENT_QUEUE_GET_CLASS(self)->add_func (self, msg); + g_free(info->msg_id); + g_slice_free(SendInfo, info); } - -static void -modest_tny_send_queue_get_sentbox (TnySendQueue *self) +static GList* +modest_tny_send_queue_lookup_info (ModestTnySendQueue *self, const gchar *msg_id) { - MODEST_TNY_SENT_QUEUE_GET_CLASS(self)->get_sentbox (self); -} + 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_get_outbox (TnySendQueue *self, TnyMsg *msg) +modest_tny_send_queue_cancel (TnySendQueue *self, gboolean remove, GError **err) { - MODEST_TNY_SENT_QUEUE_GET_CLASS(self)->get_outbox (self); -} + ModestTnySendQueuePrivate *priv; + SendInfo *info; + TnyIterator *iter = NULL; + TnyFolder *outbox = NULL; + TnyList *headers = tny_simple_list_new (); + TnyHeader *header = 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); + } -static void -modest_tny_send_queue_cancel_default (TnySendQueue *self, gboolean remove) -{ - /* FIXME */ + /* 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); } - static void -modest_tny_send_queue_add_default (TnySendQueue *self, TnyMsg *msg) +modest_tny_send_queue_add (TnySendQueue *self, TnyMsg *msg, GError **err) { - ModestTnySendQueuePriv *priv; + ModestTnySendQueuePrivate *priv; + TnyHeader *header = NULL; + SendInfo *info = NULL; + GList* existing = NULL; + const gchar* msg_id = NULL; - g_return_if_fail (self, NULL); - g_return_if_fail (TNY_IS_CAMEL_MSG(msg), NULL); - - priv = MODEST_TNY_SEND_QUEUE_GET_PRIVATE (self); + g_return_if_fail (TNY_IS_SEND_QUEUE(self)); + g_return_if_fail (TNY_IS_CAMEL_MSG(msg)); - /* FIXME */ + priv = MODEST_TNY_SEND_QUEUE_GET_PRIVATE (self); + header = tny_msg_get_header (msg); + /* Note that this call actually sets the message id to something + * sensible. */ + TNY_CAMEL_SEND_QUEUE_CLASS(parent_class)->add_func (self, msg, err); /* FIXME */ + + /* Check whether the mail is already in the queue */ +/* msg_id = tny_header_get_message_id (header); */ + msg_id = tny_header_get_uid (header); + g_return_if_fail (msg_id != NULL); + 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); + + info = existing->data; + info->status = MODEST_TNY_SEND_QUEUE_WAITING; + } + else + { + + info = g_slice_new (SendInfo); + + info->msg_id = strdup(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); + + /* free */ + g_object_unref (header); } +static void +_add_message (ModestTnySendQueue *self, TnyHeader *header) +{ + ModestWindowMgr *mgr = NULL; + ModestTnySendQueuePrivate *priv; + SendInfo *info = NULL; + GList* existing = NULL; + gchar* msg_uid = NULL; + ModestTnySendQueueStatus status = MODEST_TNY_SEND_QUEUE_WAITING; + gboolean editing = FALSE; + + g_return_if_fail (TNY_IS_SEND_QUEUE(self)); + g_return_if_fail (TNY_IS_HEADER(header)); + priv = MODEST_TNY_SEND_QUEUE_GET_PRIVATE (self); + + /* Check whether the mail is already in the queue */ + 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_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) return; + + /* Check if its being edited */ + mgr = modest_runtime_get_window_mgr (); + editing = modest_window_mgr_find_registered_header (mgr, header, NULL); + if (editing) return; + + /* Add new meesage info */ + info = g_slice_new (SendInfo); + info->msg_id = strdup(msg_uid); + info->status = MODEST_TNY_SEND_QUEUE_WAITING; + g_queue_push_tail (priv->queue, info); + break; + default: + goto frees; + } + + /* Free */ + frees: + g_free(msg_uid); +} static TnyFolder* -modest_tny_send_queue_get_sentbox_default (TnySendQueue *self) +modest_tny_send_queue_get_sentbox (TnySendQueue *self) { - ModestTnySendQueuePriv *priv; - + TnyFolder *folder; + TnyCamelTransportAccount *account; + g_return_val_if_fail (self, NULL); - priv = MODEST_TNY_SEND_QUEUE_GET_PRIVATE (self); - - return modest_tny_account_get_special_folder (priv->account, - TNY_FOLDER_TYPE_SENT); + 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)); + + return folder; } static TnyFolder* -modest_tny_send_queue_get_outbox_default (TnySendQueue *self) +modest_tny_send_queue_get_outbox (TnySendQueue *self) { - ModestTnySendQueuePriv *priv; + TnyFolder *folder; + TnyCamelTransportAccount *account; g_return_val_if_fail (self, NULL); - - priv = MODEST_TNY_SEND_QUEUE_GET_PRIVATE (self); - return modest_tny_account_get_special_folder (priv->account, - TNY_FOLDER_TYPE_OUTBOX); -} + 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)); + return folder; +} GType modest_tny_send_queue_get_type (void) { static GType my_type = 0; - if (!my_type) { + + if (my_type == 0) { static const GTypeInfo my_info = { sizeof(ModestTnySendQueueClass), NULL, /* base init */ @@ -150,32 +326,19 @@ modest_tny_send_queue_get_type (void) NULL, /* class finalize */ NULL, /* class data */ sizeof(ModestTnySendQueue), - 1, /* n_preallocs */ - (GInstanceInitFunc) modest_tny_send_queue_init, + 0, /* n_preallocs */ + (GInstanceInitFunc) modest_tny_send_queue_instance_init, NULL }; - my_type = g_type_register_static (TNY__TYPE__SEND_QUEUE, - "ModestTnySendQueue", - &my_info, 0); + my_type = g_type_register_static (TNY_TYPE_CAMEL_SEND_QUEUE, + "ModestTnySendQueue", + &my_info, 0); } return my_type; } static void -modest_tny_send_queue_init (gpointer g, gpointer iface_data) -{ - TnySendQueueIface *klass = (TnySendQueueIface*)g; - - klass->add_func = modest_tny_send_queue_add; - klass->get_outbox_func = modest_tny_send_queue_get_outbox; - klass->get_sentbox_func = modest_tny_send_queue_get_sentbox; - klass->cancel_func = modest_tny_send_queue_cancel; -} - - - -static void modest_tny_send_queue_class_init (ModestTnySendQueueClass *klass) { GObjectClass *gobject_class; @@ -185,10 +348,20 @@ modest_tny_send_queue_class_init (ModestTnySendQueueClass *klass) parent_class = g_type_class_peek_parent (klass); gobject_class->finalize = modest_tny_send_queue_finalize; - klass->add_func = modest_tny_send_queue_add_default; - klass->get_outbox_func = modest_tny_send_queue_get_outbox_default; - klass->get_sentbox_func = modest_tny_send_queue_get_sentbox_default; - klass->cancel_func = modest_tny_send_queue_cancel_default; + 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; + klass->status_changed = NULL; + + signals[STATUS_CHANGED] = + g_signal_new ("status_changed", + G_TYPE_FROM_CLASS (gobject_class), + G_SIGNAL_RUN_FIRST, + G_STRUCT_OFFSET (ModestTnySendQueueClass, status_changed), + NULL, NULL, + modest_marshal_VOID__STRING_INT, + G_TYPE_NONE, 2, G_TYPE_STRING, G_TYPE_INT); g_type_class_add_private (gobject_class, sizeof(ModestTnySendQueuePrivate)); } @@ -196,43 +369,241 @@ modest_tny_send_queue_class_init (ModestTnySendQueueClass *klass) static void modest_tny_send_queue_instance_init (GTypeInstance *instance, gpointer g_class) { - ModestTnySendQueue *self; - ModestTnySendQueuePriv *priv; - - self = (ModestTnySendQueue*)instance; - priv = MODEST_TNY_SEND_QUEUE_GET_PRIVATE (self); + ModestTnySendQueuePrivate *priv; - priv->account = NULL; + priv = MODEST_TNY_SEND_QUEUE_GET_PRIVATE (instance); + priv->queue = g_queue_new(); + priv->current = NULL; } static void modest_tny_send_queue_finalize (GObject *obj) { - ModestTnySendQueuePriv *priv; + ModestTnySendQueuePrivate *priv; + priv = MODEST_TNY_SEND_QUEUE_GET_PRIVATE (obj); - - if (priv->account) { - g_object_unref (priv->account); - priv->account = NULL; - } - + + 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); } ModestTnySendQueue* -modest_tny_send_queue_new (TnyTransportAccount *account) +modest_tny_send_queue_new (TnyCamelTransportAccount *account) { ModestTnySendQueue *self; + + 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), + NULL); + g_signal_connect (G_OBJECT(self), "msg-sent", + G_CALLBACK(_on_msg_has_been_sent), + NULL); + g_signal_connect (G_OBJECT(self), "error-happened", + G_CALLBACK(_on_msg_error_happened), + NULL); + return self; +} + + + +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; + + 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; + + 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); + } + + 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); +} + +gboolean +modest_tny_send_queue_msg_is_being_sent (ModestTnySendQueue* self, + const gchar *msg_id) +{ + ModestTnySendQueueStatus status; + + g_return_val_if_fail (msg_id != NULL, FALSE); + + status = modest_tny_send_queue_get_msg_status (self, msg_id); + return status == MODEST_TNY_SEND_QUEUE_SENDING; +} + +gboolean +modest_tny_send_queue_sending_in_progress (ModestTnySendQueue* self) +{ ModestTnySendQueuePrivate *priv; + priv = MODEST_TNY_SEND_QUEUE_GET_PRIVATE (self); + + return priv->current != NULL; +} - g_return_val_if_fail (account, NULL); +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; +} + +gchar * +modest_tny_send_queue_get_msg_id (TnyHeader *header) +{ + const gchar *uid = NULL; + gchar* msg_uid = NULL; + gchar **tmp = NULL; + + /* Get message uid */ + uid = tny_header_get_uid (header); + tmp = g_strsplit (uid, "__", 2); + if (tmp[1] != NULL) + msg_uid = g_strconcat (tmp[0], "_", NULL); + else + msg_uid = g_strdup(tmp[0]); + + /* free */ + g_strfreev(tmp); + + return msg_uid; +} + + +static void +_on_msg_start_sending (TnySendQueue *self, + TnyHeader *header, + TnyMsg *msg, + int done, + int total, + gpointer user_data) +{ + ModestTnySendQueuePrivate *priv = NULL; + GList *item = NULL; + SendInfo *info = NULL; + gchar *msg_id = NULL; + + priv = MODEST_TNY_SEND_QUEUE_GET_PRIVATE (self); - self = MODEST_TNY_SEND_QUEUE(g_object_new(MODEST_TYPE_TNY_SEND_QUEUE, NULL)); + /* 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); + g_return_if_fail (item != NULL); + 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); + priv->current = item; + + /* free */ + g_free (msg_id); +} + +static void +_on_msg_has_been_sent (TnySendQueue *self, + TnyHeader *header, + TnyMsg *msg, + int done, + int total, + gpointer user_data) +{ + ModestTnySendQueuePrivate *priv; + GList *item; + gchar *msg_id = NULL; + priv = MODEST_TNY_SEND_QUEUE_GET_PRIVATE (self); - priv->account = account; - g_object_ref (G_OBJECT(priv->account)); + /* Get message uid */ + msg_id = modest_tny_send_queue_get_msg_id (header); - return self; + /* Get status info */ + item = modest_tny_send_queue_lookup_info (MODEST_TNY_SEND_QUEUE (self), msg_id); + g_return_if_fail(item != NULL); + + /* Remove status info */ + modest_tny_send_queue_info_free (item->data); + g_queue_delete_link (priv->queue, item); + priv->current = NULL; + + /* free */ + g_free(msg_id); } +static void +_on_msg_error_happened (TnySendQueue *self, + TnyHeader *header, + TnyMsg *msg, + GError *err, + 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; + + /* Notify status has changed */ + g_signal_emit (self, signals[STATUS_CHANGED], 0, info->msg_id, info->status); + + /* free */ + g_free(msg_uid); +}