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-camel-msg.h>
36 #include <modest-tny-account.h>
37 #include <modest-marshal.h>
38 #include <string.h> /* strcmp */
40 /* 'private'/'protected' functions */
41 static void modest_tny_send_queue_class_init (ModestTnySendQueueClass *klass);
42 static void modest_tny_send_queue_finalize (GObject *obj);
43 static void modest_tny_send_queue_instance_init (GTypeInstance *instance, gpointer g_class);
46 static void _on_msg_start_sending (TnySendQueue *self, TnyMsg *msg, gpointer user_data);
47 static void _on_msg_has_been_sent (TnySendQueue *self, TnyMsg *msg, gpointer user_data);
48 static void _on_msg_error_happened (TnySendQueue *self, TnyHeader *header, TnyMsg *msg, GError *err, gpointer user_data);
59 typedef struct _SendInfo SendInfo;
62 ModestTnySendQueueStatus status;
65 typedef struct _ModestTnySendQueuePrivate ModestTnySendQueuePrivate;
66 struct _ModestTnySendQueuePrivate {
70 /* The info that is currently being sent */
74 #define MODEST_TNY_SEND_QUEUE_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE((o), \
75 MODEST_TYPE_TNY_SEND_QUEUE, \
76 ModestTnySendQueuePrivate))
79 static TnyCamelSendQueueClass *parent_class = NULL;
81 /* uncomment the following if you have defined any signals */
82 static guint signals[LAST_SIGNAL] = {0};
85 * this thread actually tries to send all the mails in the outbox and keeps
86 * track of their state.
90 on_modest_tny_send_queue_compare_id(gconstpointer info, gconstpointer msg_id)
92 return strcmp( ((SendInfo*)info)->msg_id, msg_id);
96 modest_tny_send_queue_info_free(SendInfo *info)
99 g_slice_free(SendInfo, info);
103 modest_tny_send_queue_lookup_info (ModestTnySendQueue *self, const gchar *msg_id)
105 ModestTnySendQueuePrivate *priv;
106 priv = MODEST_TNY_SEND_QUEUE_GET_PRIVATE (self);
108 return g_queue_find_custom (priv->queue, msg_id, on_modest_tny_send_queue_compare_id);
112 modest_tny_send_queue_cancel (TnySendQueue *self, gboolean remove, GError **err)
114 ModestTnySendQueuePrivate *priv;
117 priv = MODEST_TNY_SEND_QUEUE_GET_PRIVATE (self);
118 if(priv->current != NULL)
120 info = priv->current->data;
121 priv->current = NULL;
123 /* Keep in list until retry, so that we know that this was suspended
124 * by the user and not by an error. */
125 info->status = MODEST_TNY_SEND_QUEUE_SUSPENDED;
127 g_signal_emit (self, signals[STATUS_CHANGED], 0, info->msg_id, info->status);
130 TNY_CAMEL_SEND_QUEUE_CLASS(parent_class)->cancel_func (self, remove, err); /* FIXME */
134 modest_tny_send_queue_add (TnySendQueue *self, TnyMsg *msg, GError **err)
136 ModestTnySendQueuePrivate *priv;
138 SendInfo *info = NULL;
142 g_return_if_fail (TNY_IS_SEND_QUEUE(self));
143 g_return_if_fail (TNY_IS_CAMEL_MSG(msg));
145 priv = MODEST_TNY_SEND_QUEUE_GET_PRIVATE (self);
146 header = tny_msg_get_header (msg);
148 /* FIXME: do something smart here... */
150 /* Note that this call actually sets the message id to something
152 TNY_CAMEL_SEND_QUEUE_CLASS(parent_class)->add_func (self, msg, err); /* FIXME */
154 /* Check whether the mail is already in the queue */
155 msg_id = tny_header_get_message_id (header);
156 existing = modest_tny_send_queue_lookup_info (MODEST_TNY_SEND_QUEUE(self), msg_id);
159 //g_assert(info->status == MODEST_TNY_SEND_QUEUE_SUSPENDED ||
160 // info->status == MODEST_TNY_SEND_QUEUE_FAILED);
162 info = existing->data;
163 info->status = MODEST_TNY_SEND_QUEUE_WAITING;
168 info = g_slice_new (SendInfo);
170 info->msg_id = strdup(msg_id);
171 info->status = MODEST_TNY_SEND_QUEUE_WAITING;
172 g_queue_push_tail (priv->queue, info);
175 g_signal_emit (self, signals[STATUS_CHANGED], 0, info->msg_id, info->status);
179 modest_tny_send_queue_get_sentbox (TnySendQueue *self)
182 TnyCamelTransportAccount *account;
184 g_return_val_if_fail (self, NULL);
186 account = tny_camel_send_queue_get_transport_account (TNY_CAMEL_SEND_QUEUE(self));
188 g_printerr ("modest: no account for send queue\n");
191 folder = modest_tny_account_get_special_folder (TNY_ACCOUNT(account),
192 TNY_FOLDER_TYPE_SENT);
193 g_object_unref (G_OBJECT(account));
200 modest_tny_send_queue_get_outbox (TnySendQueue *self)
203 TnyCamelTransportAccount *account;
205 g_return_val_if_fail (self, NULL);
207 account = tny_camel_send_queue_get_transport_account (TNY_CAMEL_SEND_QUEUE(self));
209 g_printerr ("modest: no account for send queue\n");
212 folder = modest_tny_account_get_special_folder (TNY_ACCOUNT(account),
213 TNY_FOLDER_TYPE_OUTBOX);
214 g_object_unref (G_OBJECT(account));
220 modest_tny_send_queue_get_type (void)
222 static GType my_type = 0;
225 static const GTypeInfo my_info = {
226 sizeof(ModestTnySendQueueClass),
227 NULL, /* base init */
228 NULL, /* base finalize */
229 (GClassInitFunc) modest_tny_send_queue_class_init,
230 NULL, /* class finalize */
231 NULL, /* class data */
232 sizeof(ModestTnySendQueue),
234 (GInstanceInitFunc) modest_tny_send_queue_instance_init,
237 my_type = g_type_register_static (TNY_TYPE_CAMEL_SEND_QUEUE,
238 "ModestTnySendQueue",
246 modest_tny_send_queue_class_init (ModestTnySendQueueClass *klass)
248 GObjectClass *gobject_class;
250 gobject_class = (GObjectClass*) klass;
252 parent_class = g_type_class_peek_parent (klass);
253 gobject_class->finalize = modest_tny_send_queue_finalize;
255 TNY_CAMEL_SEND_QUEUE_CLASS(klass)->add_func = modest_tny_send_queue_add;
256 TNY_CAMEL_SEND_QUEUE_CLASS(klass)->get_outbox_func = modest_tny_send_queue_get_outbox;
257 TNY_CAMEL_SEND_QUEUE_CLASS(klass)->get_sentbox_func = modest_tny_send_queue_get_sentbox;
258 TNY_CAMEL_SEND_QUEUE_CLASS(klass)->cancel_func = modest_tny_send_queue_cancel;
259 klass->status_changed = NULL;
261 signals[STATUS_CHANGED] =
262 g_signal_new ("status_changed",
263 G_TYPE_FROM_CLASS (gobject_class),
265 G_STRUCT_OFFSET (ModestTnySendQueueClass, status_changed),
267 modest_marshal_VOID__STRING_INT,
268 G_TYPE_NONE, 2, G_TYPE_STRING, G_TYPE_INT);
270 g_type_class_add_private (gobject_class, sizeof(ModestTnySendQueuePrivate));
274 modest_tny_send_queue_instance_init (GTypeInstance *instance, gpointer g_class)
276 ModestTnySendQueuePrivate *priv;
278 priv = MODEST_TNY_SEND_QUEUE_GET_PRIVATE (instance);
279 priv->queue = g_queue_new();
280 priv->current = NULL;
284 modest_tny_send_queue_finalize (GObject *obj)
286 ModestTnySendQueuePrivate *priv;
288 priv = MODEST_TNY_SEND_QUEUE_GET_PRIVATE (obj);
290 g_queue_foreach (priv->queue, (GFunc)modest_tny_send_queue_info_free, NULL);
291 g_queue_free (priv->queue);
293 G_OBJECT_CLASS(parent_class)->finalize (obj);
297 modest_tny_send_queue_new (TnyCamelTransportAccount *account)
299 ModestTnySendQueue *self;
301 g_return_val_if_fail (TNY_IS_CAMEL_TRANSPORT_ACCOUNT(account), NULL);
303 self = MODEST_TNY_SEND_QUEUE(g_object_new(MODEST_TYPE_TNY_SEND_QUEUE, NULL));
305 tny_camel_send_queue_set_transport_account (TNY_CAMEL_SEND_QUEUE(self),
308 /* Connect signals to control when a msg is being or has been sent */
309 /* TODO: this signal was implemented in tinymail camel send queue, but im
310 waiting for implement some unit tests nbefore commited changes */
312 g_signal_connect (G_OBJECT(self), "msg-sending",
313 G_CALLBACK(_on_msg_start_sending),
317 g_signal_connect (G_OBJECT(self), "msg-sent",
318 G_CALLBACK(_on_msg_has_been_sent),
320 g_signal_connect (G_OBJECT(self), "error-happened",
321 G_CALLBACK(_on_msg_error_happened),
329 modest_tny_send_queue_try_to_send (ModestTnySendQueue* self)
331 /* TODO: Rename this to tny_camel_send_queue_try_to_send() in tinymail
332 and check that it works, without creating a second worker. */
333 /* tny_camel_send_queue_flush (TNY_CAMEL_SEND_QUEUE(self)); */
338 modest_tny_send_queue_msg_is_being_sent (ModestTnySendQueue* self,
341 ModestTnySendQueuePrivate *priv;
343 g_return_val_if_fail (msg_id != NULL, FALSE);
344 priv = MODEST_TNY_SEND_QUEUE_GET_PRIVATE (self);
346 if (modest_tny_send_queue_sending_in_progress(self))
347 return g_ascii_strcasecmp(priv->current_msg_id, msg_id);
354 modest_tny_send_queue_sending_in_progress (ModestTnySendQueue* self)
356 ModestTnySendQueuePrivate *priv;
357 priv = MODEST_TNY_SEND_QUEUE_GET_PRIVATE (self);
359 return priv->current != NULL;
362 ModestTnySendQueueStatus
363 modest_tny_send_queue_get_msg_status (ModestTnySendQueue *self, const gchar *msg_id)
366 item = modest_tny_send_queue_lookup_info (self, msg_id);
367 if(item == NULL) return MODEST_TNY_SEND_QUEUE_SUSPENDED;
368 return ((SendInfo*)item->data)->status;
372 _on_msg_start_sending (TnySendQueue *self,
376 ModestTnySendQueuePrivate *priv;
381 priv = MODEST_TNY_SEND_QUEUE_GET_PRIVATE (self);
383 header = tny_msg_get_header(msg);
384 item = modest_tny_send_queue_lookup_info (MODEST_TNY_SEND_QUEUE (self), tny_header_get_message_id (header));
389 info->status = MODEST_TNY_SEND_QUEUE_SENDING;
391 g_signal_emit (self, signals[STATUS_CHANGED], 0, info->msg_id, info->status);
394 priv->current = item;
398 _on_msg_has_been_sent (TnySendQueue *self,
402 ModestTnySendQueuePrivate *priv;
406 priv = MODEST_TNY_SEND_QUEUE_GET_PRIVATE (self);
408 header = tny_msg_get_header (msg);
410 /* TODO: Use this version as soon as the msg-sending
411 * notification works */
413 item = priv->current;
414 g_assert(item != NULL);
416 item = modest_tny_send_queue_lookup_info (MODEST_TNY_SEND_QUEUE (self), tny_header_get_message_id(header));
417 g_assert(item != NULL);
420 modest_tny_send_queue_info_free (item->data);
421 g_queue_delete_link (priv->queue, item);
422 priv->current = NULL;
425 static void _on_msg_error_happened (TnySendQueue *self,
431 ModestTnySendQueuePrivate *priv;
435 priv = MODEST_TNY_SEND_QUEUE_GET_PRIVATE (self);
437 /* TODO: Use this version as soon as the msg-sending
438 * notification works */
440 item = priv->current;
441 g_assert(item != NULL);
442 info = priv->current->data;
444 /* TODO: Why do we get the msg and its header separately? The docs
445 * don't really tell. */
446 g_assert(header == tny_msg_get_header (msg)); // ????
447 item = modest_tny_send_queue_lookup_info (MODEST_TNY_SEND_QUEUE (self), tny_header_get_message_id (header));
448 g_assert(item != NULL);
452 /* Keep in queue so that we remember that the opertion has failed
453 * and was not just cancelled */
454 info->status = MODEST_TNY_SEND_QUEUE_FAILED;
455 g_signal_emit (self, signals[STATUS_CHANGED], 0, info->msg_id, info->status);