GError *err,
gpointer user_data);
+static gboolean _check_memory_low (ModestMailOperation *mail_op);
+
enum _ModestMailOperationSignals
{
PROGRESS_CHANGED_SIGNAL,
if (priv->op_type == MODEST_MAIL_OPERATION_TYPE_SEND) {
ModestTnySendQueue *queue;
- queue = modest_runtime_get_send_queue (TNY_TRANSPORT_ACCOUNT (priv->account));
+ queue = modest_runtime_get_send_queue (TNY_TRANSPORT_ACCOUNT (priv->account),
+ TRUE);
/* Cancel the sending of the following next messages */
tny_send_queue_cancel (TNY_SEND_QUEUE (queue), TNY_SEND_QUEUE_CANCEL_ACTION_SUSPEND, NULL);
/* ************************** SEND ACTIONS ************************* */
/* ******************************************************************* */
+static void
+send_mail_on_added_to_outbox (TnySendQueue *send_queue,
+ gboolean cancelled,
+ TnyMsg *msg,
+ GError *err,
+ gpointer user_data)
+{
+ ModestMailOperationPrivate *priv;
+ ModestMailOperation *self;
+
+ self = MODEST_MAIL_OPERATION (user_data);
+ priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
+
+ if (cancelled || err)
+ goto end;
+
+ if (err) {
+ g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
+ MODEST_MAIL_OPERATION_ERROR_SEND_QUEUE_ADD_ERROR,
+ "Error adding a msg to the send queue\n");
+ priv->status = MODEST_MAIL_OPERATION_STATUS_FINISHED_WITH_ERRORS;
+ } else {
+ priv->status = MODEST_MAIL_OPERATION_STATUS_SUCCESS;
+ }
+ end:
+ modest_mail_operation_notify_end (self);
+ g_object_unref (self);
+}
+
void
modest_mail_operation_send_mail (ModestMailOperation *self,
TnyTransportAccount *transport_account,
priv->done = 1;
priv->total = 1;
- send_queue = TNY_SEND_QUEUE (modest_runtime_get_send_queue (transport_account));
+ send_queue = TNY_SEND_QUEUE (modest_runtime_get_send_queue (transport_account, TRUE));
if (!TNY_IS_SEND_QUEUE(send_queue)) {
+ if (priv->error) {
+ g_error_free (priv->error);
+ priv->error = NULL;
+ }
g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
MODEST_MAIL_OPERATION_ERROR_ITEM_NOT_FOUND,
"modest: could not find send queue for account\n");
priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
modest_mail_operation_notify_end (self);
-
} else {
- /* Add the msg to the queue */
modest_mail_operation_notify_start (self);
-
- tny_send_queue_add_async (send_queue, msg, NULL, NULL, NULL);
- modest_tny_send_queue_set_requested_send_receive (MODEST_TNY_SEND_QUEUE (send_queue), FALSE);
-
- priv->status = MODEST_MAIL_OPERATION_STATUS_SUCCESS;
- modest_mail_operation_notify_end (self);
+ /* Add the msg to the queue. The callback will
+ finalize the mail operation */
+ tny_send_queue_add_async (send_queue, msg, send_mail_on_added_to_outbox,
+ NULL, g_object_ref (self));
+ modest_tny_send_queue_set_requested_send_receive (MODEST_TNY_SEND_QUEUE (send_queue),
+ FALSE);
}
-
}
if (info->html_body == NULL) {
new_msg = modest_tny_msg_new (info->to, info->from, info->cc,
info->bcc, info->subject, info->plain_body,
- info->attachments_list);
+ info->attachments_list,
+ &(priv->error));
} else {
new_msg = modest_tny_msg_new_html_plain (info->to, info->from, info->cc,
info->bcc, info->subject, info->html_body,
info->plain_body, info->attachments_list,
- info->images_list);
+ info->images_list,
+ &(priv->error));
}
if (new_msg) {
g_object_unref (G_OBJECT(header));
} else {
priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
- g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
- MODEST_MAIL_OPERATION_ERROR_INSTANCE_CREATION_FAILED,
- "modest: failed to create a new msg\n");
+ if (!priv->error)
+ g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
+ MODEST_MAIL_OPERATION_ERROR_INSTANCE_CREATION_FAILED,
+ "modest: failed to create a new msg\n");
}
TnyFolder *draft_folder = NULL;
TnyFolder *outbox_folder = NULL;
TnyHeader *header = NULL;
- GError *err = NULL;
+
+ priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
if (!msg) {
+ priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
+ modest_mail_operation_notify_end (self);
goto end;
}
- priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
-
- if (priv->error) {
+ if (priv->error && priv->error->code != MODEST_MAIL_OPERATION_ERROR_FILE_IO) {
priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
modest_mail_operation_notify_end (self);
goto end;
modest_mail_operation_send_mail (self, info->transport_account, msg);
if (info->draft_msg != NULL) {
+ TnyList *tmp_headers = NULL;
TnyFolder *folder = NULL;
TnyFolder *src_folder = NULL;
TnyFolderType folder_type;
src_folder = draft_folder;
/* Note: This can fail (with a warning) if the message is not really already in a folder,
- * because this function requires it to have a UID. */
- tny_folder_remove_msg (src_folder, header, NULL);
-
- tny_folder_sync (folder, TRUE, &err); /* FALSE --> don't expunge */
-/* tny_folder_sync_async (src_folder, TRUE, NULL, NULL, NULL); /\* expunge *\/ */
+ * because this function requires it to have a UID. */
+ tmp_headers = tny_simple_list_new ();
+ tny_list_append (tmp_headers, (GObject*) header);
+ tny_folder_remove_msgs_async (src_folder, tmp_headers, NULL, NULL, NULL);
+ g_object_unref (tmp_headers);
+ tny_folder_sync_async (src_folder, TRUE, NULL, NULL, NULL); /* expunge */
g_object_unref (folder);
}
end:
if (header)
g_object_unref (header);
- if (err != NULL)
- g_error_free(err);
if (info->draft_msg)
g_object_unref (info->draft_msg);
if (draft_folder)
{
ModestMailOperationPrivate *priv = NULL;
SaveToDraftsAddMsgInfo *info = (SaveToDraftsAddMsgInfo *) userdata;
+ GError *io_error = NULL;
priv = MODEST_MAIL_OPERATION_GET_PRIVATE(info->mailop);
+ if (priv->error && priv->error->code == MODEST_MAIL_OPERATION_ERROR_FILE_IO) {
+ io_error = priv->error;
+ priv->error = NULL;
+ }
if (priv->error) {
g_warning ("%s: priv->error != NULL", __FUNCTION__);
g_error_free(priv->error);
g_object_unref (G_OBJECT(src_folder));
}
- if (!priv->error)
- priv->status = MODEST_MAIL_OPERATION_STATUS_SUCCESS;
- else
+ if (priv->error) {
priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
+ if (io_error) {
+ g_error_free (io_error);
+ io_error = NULL;
+ }
+ } else if (io_error) {
+ priv->error = io_error;
+ priv->status = MODEST_MAIL_OPERATION_STATUS_FINISHED_WITH_ERRORS;
+ } else {
+ priv->status = MODEST_MAIL_OPERATION_STATUS_SUCCESS;
+ }
/* Call the user callback */
if (info->callback)
}
}
- if (!priv->error) {
+ if (!priv->error || priv->error->code == MODEST_MAIL_OPERATION_ERROR_FILE_IO) {
SaveToDraftsAddMsgInfo *cb_info = g_slice_new(SaveToDraftsAddMsgInfo);
cb_info->transport_account = g_object_ref(info->transport_account);
cb_info->draft_msg = info->draft_msg ? g_object_ref(info->draft_msg) : NULL;
ModestAccountMgr *mgr;
ModestAccountRetrieveType retrieve_type;
TnyList *new_headers = NULL;
- gboolean headers_only, ignore_limit, succeeded;
+ gboolean headers_only, ignore_limit;
TnyTransportAccount *transport_account = NULL;
info = (UpdateAccountInfo *) user_data;
priv = MODEST_MAIL_OPERATION_GET_PRIVATE (info->mail_op);
mgr = modest_runtime_get_account_mgr ();
+ /* Set the last updated as the current time, do it even if the inbox refresh failed */
+ modest_account_mgr_set_last_updated (mgr, tny_account_get_id (priv->account), time (NULL));
+
if (canceled || err) {
priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
if (err)
g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
MODEST_MAIL_OPERATION_ERROR_OPERATION_CANCELED,
"canceled");
+
/* Notify the user about the error and then exit */
update_account_notify_user_and_free (info, NULL);
return;
g_object_unref (info->inbox_observer);
info->inbox_observer = NULL;
- /* Update the last updated key, even if we don't have to get new headers */
- modest_account_mgr_set_last_updated (mgr, tny_account_get_id (priv->account), time (NULL));
- if (!canceled && !err)
- modest_account_mgr_set_server_account_username_has_succeeded (mgr, tny_account_get_id (priv->account), TRUE);
-
if (new_headers_array->len == 0)
goto send_mail;
g_ptr_array_foreach (new_headers_array, (GFunc) g_object_unref, NULL);
g_ptr_array_free (new_headers_array, FALSE);
- if (priv->error)
- succeeded = FALSE;
- else
- succeeded = TRUE;
- modest_account_mgr_set_server_account_username_has_succeeded (modest_runtime_get_account_mgr (),
- tny_account_get_name (priv->account),
- succeeded);
send_mail:
/* Get the transport account */
transport_account = (TnyTransportAccount *)
TnyFolder *outbox;
guint num_messages;
- send_queue = modest_runtime_get_send_queue (transport_account);
+ send_queue = modest_runtime_get_send_queue (transport_account, TRUE);
g_object_unref (transport_account);
/* Get outbox folder */
update_account_notify_user_and_free (info, new_headers);
}
+static void
+inbox_refresh_status_update (GObject *obj,
+ TnyStatus *status,
+ gpointer user_data)
+{
+ UpdateAccountInfo *info = NULL;
+ ModestMailOperation *self = NULL;
+ ModestMailOperationPrivate *priv = NULL;
+ ModestMailOperationState *state;
+
+ g_return_if_fail (user_data != NULL);
+ g_return_if_fail (status != NULL);
+
+ /* Show only the status information we want */
+ if (status->code != TNY_FOLDER_STATUS_CODE_REFRESH)
+ return;
+
+ info = (UpdateAccountInfo *) user_data;
+ self = info->mail_op;
+ g_return_if_fail (MODEST_IS_MAIL_OPERATION(self));
+
+ priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
+
+ priv->done = status->position;
+ priv->total = status->of_total;
+
+ state = modest_mail_operation_clone_state (self);
+
+ /* This is not a GDK lock because we are a Tinymail callback and
+ * Tinymail already acquires the Gdk lock */
+ g_signal_emit (G_OBJECT (self), signals[PROGRESS_CHANGED_SIGNAL], 0, state, NULL);
+
+ g_slice_free (ModestMailOperationState, state);
+}
+
static void
recurse_folders_async_cb (TnyFolderStore *folder_store,
gboolean canceled,
tny_folder_add_observer (inbox, info->inbox_observer);
/* Refresh the INBOX */
- tny_folder_refresh_async (inbox, inbox_refreshed_cb, NULL, info);
+ tny_folder_refresh_async (inbox, inbox_refreshed_cb, inbox_refresh_status_update, info);
g_object_unref (inbox);
} else {
/* We could not perform the inbox refresh but
transfer_folder_cb,
transfer_folder_status_cb,
helper);
+ g_object_unref (into);
} else {
+ g_object_unref (into);
goto error;
}
- g_object_unref (into);
return;
}
void
modest_mail_operation_get_msg (ModestMailOperation *self,
TnyHeader *header,
+ gboolean progress_feedback,
GetMsgAsyncUserCallback user_callback,
gpointer user_data)
{
g_return_if_fail (TNY_IS_HEADER (header));
priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
- folder = tny_header_get_folder (header);
-
priv->status = MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS;
priv->total = 1;
priv->done = 0;
+ /* Check memory low */
+ if (_check_memory_low (self)) {
+ if (user_callback)
+ user_callback (self, header, FALSE, NULL, priv->error, user_data);
+ modest_mail_operation_notify_end (self);
+ return;
+ }
+
/* Get account and set it into mail_operation */
+ folder = tny_header_get_folder (header);
priv->account = modest_tny_folder_get_account (TNY_FOLDER(folder));
/* Check for cached messages */
- if (tny_header_get_flags (header) & TNY_HEADER_FLAG_CACHED)
- priv->op_type = MODEST_MAIL_OPERATION_TYPE_OPEN;
- else
- priv->op_type = MODEST_MAIL_OPERATION_TYPE_RECEIVE;
+ if (progress_feedback) {
+ if (tny_header_get_flags (header) & TNY_HEADER_FLAG_CACHED)
+ priv->op_type = MODEST_MAIL_OPERATION_TYPE_OPEN;
+ else
+ priv->op_type = MODEST_MAIL_OPERATION_TYPE_RECEIVE;
+ } else {
+ priv->op_type = MODEST_MAIL_OPERATION_TYPE_UNKNOWN;
+ }
/* Create the helper */
helper = g_slice_new0 (GetMsgInfo);
helper->last_total_bytes = 0;
helper->sum_total_bytes = 0;
helper->total_bytes = tny_header_get_message_size (header);
+ helper->more_msgs = NULL;
modest_mail_operation_notify_start (self);
state->total = 0;
g_signal_emit (G_OBJECT (self), signals[PROGRESS_CHANGED_SIGNAL],
0, state, NULL);
+ g_slice_free (ModestMailOperationState, state);
tny_folder_get_msg_async (folder, header, get_msg_async_cb, get_msg_status_cb, helper);
}
/* If canceled by the user, ignore the error given by Tinymail */
- if (priv->status == MODEST_MAIL_OPERATION_STATUS_CANCELED || canceled) {
+ if (canceled) {
canceled = TRUE;
finished = TRUE;
+ priv->status = MODEST_MAIL_OPERATION_STATUS_CANCELED;
} else if (err) {
priv->status = MODEST_MAIL_OPERATION_STATUS_FINISHED_WITH_ERRORS;
if (err) {
priv->done = 0;
priv->total = tny_list_get_length(header_list);
+ /* Check memory low */
+ if (_check_memory_low (self)) {
+ if (user_callback) {
+ TnyHeader *header = NULL;
+ TnyIterator *iter;
+
+ if (tny_list_get_length (header_list) > 0) {
+ iter = tny_list_create_iterator (header_list);
+ header = (TnyHeader *) tny_iterator_get_current (iter);
+ g_object_unref (iter);
+ }
+ user_callback (self, header, FALSE, NULL, priv->error, user_data);
+ if (header)
+ g_object_unref (header);
+ }
+ if (notify)
+ notify (user_data);
+ /* Notify about operation end */
+ modest_mail_operation_notify_end (self);
+ return;
+ }
+
/* Check uncached messages */
for (iter = tny_list_create_iterator (header_list), has_uncached_messages = FALSE;
!has_uncached_messages && !tny_iterator_is_done (iter);
traccount = modest_tny_account_store_get_transport_account_from_outbox_header(accstore, header);
if (traccount) {
ModestTnySendQueueStatus status;
- ModestTnySendQueue *send_queue = modest_runtime_get_send_queue(traccount);
+ ModestTnySendQueue *send_queue = modest_runtime_get_send_queue(traccount, TRUE);
TnyIterator *iter = tny_list_create_iterator(headers);
g_object_unref(remove_headers);
remove_headers = TNY_LIST(tny_simple_list_new());
&(helper->sum_total_bytes), helper->total_bytes, TRUE);
}
+static void
+transfer_msgs_sync_folder_cb (TnyFolder *self,
+ gboolean cancelled,
+ GError *err,
+ gpointer user_data)
+{
+ XFerMsgsAsyncHelper *helper;
+ /* We don't care here about the results of the
+ synchronization */
+ helper = (XFerMsgsAsyncHelper *) user_data;
+
+ /* Notify about operation end */
+ modest_mail_operation_notify_end (helper->mail_op);
+
+ /* If user defined callback function was defined, call it */
+ if (helper->user_callback)
+ helper->user_callback (helper->mail_op, helper->user_data);
+
+ /* Free */
+ if (helper->more_msgs)
+ g_object_unref (helper->more_msgs);
+ if (helper->headers)
+ g_object_unref (helper->headers);
+ if (helper->dest_folder)
+ g_object_unref (helper->dest_folder);
+ if (helper->mail_op)
+ g_object_unref (helper->mail_op);
+ g_slice_free (XFerMsgsAsyncHelper, helper);
+}
static void
transfer_msgs_cb (TnyFolder *folder, gboolean cancelled, GError *err, gpointer user_data)
priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
- if (err) {
+ if (cancelled) {
+ priv->status = MODEST_MAIL_OPERATION_STATUS_CANCELED;
+ } else if (err) {
priv->error = g_error_copy (err);
priv->done = 0;
priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
- } else if (cancelled) {
- priv->status = MODEST_MAIL_OPERATION_STATUS_CANCELED;
- g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
- MODEST_MAIL_OPERATION_ERROR_ITEM_NOT_FOUND,
- _("Error trying to refresh the contents of %s"),
- tny_folder_get_name (folder));
} else if (priv->status != MODEST_MAIL_OPERATION_STATUS_CANCELED) {
if (helper->more_msgs) {
/* We'll transfer the next message in the list */
finished = FALSE;
}
}
-
if (finished) {
priv->done = 1;
priv->status = MODEST_MAIL_OPERATION_STATUS_SUCCESS;
}
if (finished) {
-
- /* Update folder counts */
- tny_folder_poke_status (folder);
- tny_folder_poke_status (helper->dest_folder);
-
- /* Notify about operation end */
- modest_mail_operation_notify_end (self);
-
- /* If user defined callback function was defined, call it */
- if (helper->user_callback) {
- /* This is not a GDK lock because we are a Tinymail callback and
- * Tinymail already acquires the Gdk lock */
-
- /* no gdk_threads_enter (), CHECKED */
- helper->user_callback (self, helper->user_data);
- /* no gdk_threads_leave (), CHECKED */
- }
-
- /* Free */
- if (helper->more_msgs)
- g_object_unref (helper->more_msgs);
- if (helper->headers)
- g_object_unref (helper->headers);
- if (helper->dest_folder)
- g_object_unref (helper->dest_folder);
- if (helper->mail_op)
- g_object_unref (helper->mail_op);
- g_slice_free (XFerMsgsAsyncHelper, helper);
+ /* Synchronize the source folder contents. This should
+ be done by tinymail but the camel_folder_sync it's
+ actually disabled in transfer_msgs_thread_clean
+ because it's supposed to cause hangs */
+ tny_folder_sync_async (folder, helper->delete,
+ transfer_msgs_sync_folder_cb,
+ NULL, helper);
} else {
/* Transfer more messages */
tny_folder_transfer_msgs_async (folder,
helper->dest_folder = g_object_ref(folder);
helper->user_callback = user_callback;
helper->user_data = user_data;
- helper->delete = delete_original;
helper->last_total_bytes = 0;
helper->sum_total_bytes = 0;
helper->total_bytes = compute_message_list_size (headers);
leave_on_server = FALSE;
}
+ /* Do not delete messages if leave on server is TRUE */
+ helper->delete = (leave_on_server) ? FALSE : delete_original;
+
modest_mail_operation_notify_start (self);
tny_folder_transfer_msgs_async (src_folder,
helper->headers,
folder,
- (leave_on_server) ? FALSE : delete_original,
+ helper->delete,
transfer_msgs_cb,
transfer_msgs_status_cb,
helper);
priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
- priv->status = MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS;
+ /* Check memory low */
+ if (_check_memory_low (self)) {
+ if (user_callback)
+ user_callback (self, folder, user_data);
+ /* Notify about operation end */
+ modest_mail_operation_notify_end (self);
+ return;
+ }
/* Get account and set it into mail_operation */
+ priv->status = MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS;
priv->account = modest_tny_folder_get_account (folder);
priv->op_type = MODEST_MAIL_OPERATION_TYPE_RECEIVE;
priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
priv->status = MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS;
- priv->account = TNY_ACCOUNT (tny_folder_get_account (folder));
+ priv->account = modest_tny_folder_get_account (folder);
priv->op_type = MODEST_MAIL_OPERATION_TYPE_SYNC_FOLDER;
modest_mail_operation_notify_start (self);
g_object_ref (self);
- tny_folder_sync_async (folder, expunge, (TnyFolderCallback) sync_folder_finish_callback, NULL, self);
+ tny_folder_sync_async (folder, expunge,
+ (TnyFolderCallback) sync_folder_finish_callback,
+ NULL, self);
}
static void
priv->done, priv->total,
priv->error && priv->error->message ? priv->error->message : "");
}
+
+/*
+ * Once the mail operations were objects this will be no longer
+ * needed. I don't like it, but we need it for the moment
+ */
+static gboolean
+_check_memory_low (ModestMailOperation *mail_op)
+{
+ if (modest_platform_check_memory_low (NULL, FALSE)) {
+ ModestMailOperationPrivate *priv;
+
+ priv = MODEST_MAIL_OPERATION_GET_PRIVATE (mail_op);
+ priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
+ g_set_error (&(priv->error),
+ MODEST_MAIL_OPERATION_ERROR,
+ MODEST_MAIL_OPERATION_ERROR_LOW_MEMORY,
+ "Not enough memory to complete the operation");
+ return TRUE;
+ } else {
+ return FALSE;
+ }
+}