#include <tny-folder-store.h>
#include <tny-folder-store-query.h>
#include <tny-camel-stream.h>
+#include <tny-camel-pop-store-account.h>
#include <tny-simple-list.h>
#include <tny-send-queue.h>
#include <tny-status.h>
typedef struct _ModestMailOperationPrivate ModestMailOperationPrivate;
struct _ModestMailOperationPrivate {
TnyAccount *account;
+ gchar *account_name;
guint done;
guint total;
GObject *source;
typedef struct _GetMsgAsyncHelper {
ModestMailOperation *mail_op;
+ TnyHeader *header;
GetMsgAsyncUserCallback user_callback;
- guint pending_ops;
gpointer user_data;
} GetMsgAsyncHelper;
+typedef struct _RefreshAsyncHelper {
+ ModestMailOperation *mail_op;
+ RefreshAsyncUserCallback user_callback;
+ gpointer user_data;
+} RefreshAsyncHelper;
+
typedef struct _XFerMsgAsyncHelper
{
ModestMailOperation *mail_op;
priv = MODEST_MAIL_OPERATION_GET_PRIVATE(obj);
+
+
if (priv->error) {
g_error_free (priv->error);
priv->error = NULL;
{
ModestMailOperationPrivate *priv;
+ g_return_val_if_fail (self, NULL);
+
priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
-
+ if (!priv) {
+ g_warning ("BUG: %s: priv == NULL", __FUNCTION__);
+ return NULL;
+ }
+
return g_object_ref (priv->source);
}
MODEST_MAIL_OPERATION_STATUS_INVALID);
priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
+ if (!priv) {
+ g_warning ("BUG: %s: priv == NULL", __FUNCTION__);
+ return MODEST_MAIL_OPERATION_STATUS_INVALID;
+ }
+
return priv->status;
}
g_return_val_if_fail (MODEST_IS_MAIL_OPERATION (self), NULL);
priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
+
+ if (!priv) {
+ g_warning ("BUG: %s: priv == NULL", __FUNCTION__);
+ return NULL;
+ }
+
return priv->error;
}
}
priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
-
- /* cancel current operation in account */
- tny_account_cancel (priv->account);
+ if (!priv) {
+ g_warning ("BUG: %s: priv == NULL", __FUNCTION__);
+ return FALSE;
+ }
did_a_cancel = TRUE;
/* Set new status */
priv->status = MODEST_MAIL_OPERATION_STATUS_CANCELED;
- /* Notify about operation end */
+ /* This emits progress-changed on which the mail operation queue is
+ * listening, so the mail operation is correctly removed from the
+ * queue without further explicit calls. */
modest_mail_operation_notify_end (self);
-
+
return TRUE;
}
ModestMailOperationState *state;
ModestMailOperationPrivate *priv;
+ /* FIXME: this should be fixed properly
+ *
+ * in some cases, priv was NULL, so checking here to
+ * make sure.
+ */
+ g_return_val_if_fail (self, NULL);
priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
+ g_return_val_if_fail (priv, NULL);
+
+ if (!priv)
+ return NULL;
state = g_slice_new (ModestMailOperationState);
state->done = priv->done;
state->total = priv->total;
state->finished = modest_mail_operation_is_finished (self);
+ state->bytes_done = 0;
+ state->bytes_total = 0;
return state;
}
/* Get account and set it into mail_operation */
priv->account = g_object_ref (transport_account);
+ priv->done = 1;
+ priv->total = 1;
send_queue = TNY_SEND_QUEUE (modest_runtime_get_send_queue (transport_account));
if (!TNY_IS_SEND_QUEUE(send_queue)) {
MODEST_MAIL_OPERATION_ERROR_ITEM_NOT_FOUND,
"modest: could not find send queue for account\n");
} else {
+ /* TODO: connect to the msg-sent in order to know when
+ the mail operation is finished */
tny_send_queue_add (send_queue, msg, &(priv->error));
+ /* TODO: we're setting always success, do the check in
+ the handler */
+ priv->status = MODEST_MAIL_OPERATION_STATUS_SUCCESS;
}
- /* Notify about operation end */
+ /* TODO: do this in the handler of the "msg-sent"
+ signal.Notify about operation end */
modest_mail_operation_notify_end (self);
}
priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
- /* Get account and set it into mail_operation */
- priv->account = g_object_ref (transport_account);
-
/* Check parametters */
if (to == NULL) {
/* Set status failed and set an error */
/* Set priority flags in message */
header = tny_msg_get_header (new_msg);
- tny_header_set_flags (header, priority_flags);
+ if (priority_flags != 0)
+ tny_header_set_flags (header, priority_flags);
/* Call mail operation */
modest_mail_operation_send_mail (self, transport_account, new_msg);
if (draft_msg != NULL) {
header = tny_msg_get_header (draft_msg);
+ /* Remove the old draft expunging it */
tny_folder_remove_msg (folder, header, NULL);
+ tny_folder_sync (folder, TRUE, NULL);
g_object_unref (header);
}
gint max_size;
gint retrieve_limit;
gchar *retrieve_type;
+ gchar *account_name;
+ UpdateAccountCallback callback;
+ gpointer user_data;
} UpdateAccountInfo;
/***** I N T E R N A L F O L D E R O B S E R V E R *****/
state = modest_mail_operation_clone_state (mail_op);
g_signal_emit (G_OBJECT (mail_op), signals[PROGRESS_CHANGED_SIGNAL], 0, state, NULL);
g_slice_free (ModestMailOperationState, state);
-
+
return TRUE;
}
ModestMailOperationPrivate *priv = NULL;
priv = MODEST_MAIL_OPERATION_GET_PRIVATE(mail_op);
-
+
modest_mail_operation_notify_end (mail_op);
g_object_unref (mail_op);
static gpointer
update_account_thread (gpointer thr_user_data)
{
+ static gboolean first_time = TRUE;
UpdateAccountInfo *info;
TnyList *all_folders = NULL;
- GPtrArray *new_headers;
+ GPtrArray *new_headers = NULL;
TnyIterator *iter = NULL;
TnyFolderStoreQuery *query = NULL;
- ModestMailOperationPrivate *priv;
- ModestTnySendQueue *send_queue;
-
+ ModestMailOperationPrivate *priv = NULL;
+ ModestTnySendQueue *send_queue = NULL;
info = (UpdateAccountInfo *) thr_user_data;
priv = MODEST_MAIL_OPERATION_GET_PRIVATE(info->mail_op);
/* Get account and set it into mail_operation */
priv->account = g_object_ref (info->account);
+ /*
+ * for POP3, we do a logout-login upon send/receive -- many POP-servers (like Gmail) do not
+ * show any updates unless we do that
+ */
+ if (!first_time && TNY_IS_CAMEL_POP_STORE_ACCOUNT(priv->account))
+ tny_camel_pop_store_account_reconnect (TNY_CAMEL_POP_STORE_ACCOUNT(priv->account));
+
/* Get all the folders. We can do it synchronously because
we're already running in a different thread than the UI */
all_folders = tny_simple_list_new ();
/* Refresh the folder */
/* Our observer receives notification of new emails during folder refreshes,
* so we can use observer->new_headers.
- * TODO: This does not seem to be providing accurate numbers.
- * Possibly the observer is notified asynchronously.
*/
observer = g_object_new (internal_folder_observer_get_type (), NULL);
tny_folder_add_observer (TNY_FOLDER (folder), TNY_FOLDER_OBSERVER (observer));
iter = tny_list_create_iterator (observer->new_headers);
while (!tny_iterator_is_done (iter)) {
TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter));
- /* printf (" DEBUG1.2 %s: checking size: account=%s, subject=%s\n",
- * __FUNCTION__, tny_account_get_id (priv->account),
- * tny_header_get_subject (header));
- */
/* Apply per-message size limits */
if (tny_header_get_message_size (header) < info->max_size)
tny_iterator_next (iter);
}
g_object_unref (iter);
- } else /* If it's headers only, then just poke the folder status (this will update the unread and total count of folder observers, like the folder list model*/
- tny_folder_poke_status (TNY_FOLDER (folder));
-
+ } else {
+ /* We do not need to do it the first time
+ because it's automatically done by the tree
+ model */
+ if (G_UNLIKELY (!first_time))
+ tny_folder_poke_status (TNY_FOLDER (folder));
+ }
tny_folder_remove_observer (TNY_FOLDER (folder), TNY_FOLDER_OBSERVER (observer));
g_object_unref (observer);
observer = NULL;
* user to download them all,
* as per the UI spec "Retrieval Limits" section in 4.4:
*/
- printf ("DEBUG: %s: account=%s, len=%d, retrieve_limit = %d\n", __FUNCTION__,
- tny_account_get_id (priv->account), new_headers->len, info->retrieve_limit);
if (new_headers->len > info->retrieve_limit) {
- /* TODO: Ask the user, instead of just failing, showing mail_nc_msg_count_limit_exceeded,
- * with 'Get all' and 'Newest only' buttons. */
+ /* TODO: Ask the user, instead of just
+ * failing, showing
+ * mail_nc_msg_count_limit_exceeded, with 'Get
+ * all' and 'Newest only' buttons. */
g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
MODEST_MAIL_OPERATION_ERROR_RETRIEVAL_NUMBER_LIMIT,
"The number of messages to retrieve exceeds the chosen limit for account %s\n",
if (!priv->error) {
priv->status = MODEST_MAIL_OPERATION_STATUS_SUCCESS;
- /* Update the last updated key. TODO: this causes
- sometimes an error in dbus, in order to fix this we
- must call gconf from the main loop */
+ /* Update the last updated key */
g_idle_add_full (G_PRIORITY_HIGH_IDLE,
set_last_updated_idle,
g_strdup (tny_account_get_id (TNY_ACCOUNT (info->account))),
/* Notify about operation end. Note that the info could be
freed before this idle happens, but the mail operation will
be still alive */
- g_idle_add (notify_update_account_queue, info->mail_op);
+ g_idle_add (notify_update_account_queue, g_object_ref (info->mail_op));
+ if (info->callback)
+ info->callback (info->mail_op,
+ (new_headers) ? new_headers->len : 0,
+ info->user_data);
+
/* Frees */
g_object_unref (query);
g_object_unref (all_folders);
g_free (info->retrieve_type);
g_slice_free (UpdateAccountInfo, info);
+ first_time = FALSE;
+
return NULL;
}
gboolean
modest_mail_operation_update_account (ModestMailOperation *self,
- const gchar *account_name)
+ const gchar *account_name,
+ UpdateAccountCallback callback,
+ gpointer user_data)
{
GThread *thread;
UpdateAccountInfo *info;
g_return_val_if_fail (MODEST_IS_MAIL_OPERATION (self), FALSE);
g_return_val_if_fail (account_name, FALSE);
- /* Make sure that we have a connection, and request one
- * if necessary:
- * TODO: Is there some way to trigger this for every attempt to
- * use the network? */
- if (!modest_platform_connect_and_wait(NULL))
- return FALSE;
-
/* Init mail operation. Set total and done to 0, and do not
update them, this way the progress objects will know that
we have no clue about the number of the objects */
priv->total = 0;
priv->done = 0;
priv->status = MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS;
-
+
+ /* Make sure that we have a connection, and request one
+ * if necessary:
+ * TODO: Is there some way to trigger this for every attempt to
+ * use the network? */
+ if (!modest_platform_connect_and_wait(NULL))
+ goto error;
+
/* Get the Modest account */
modest_account = (TnyStoreAccount *)
modest_tny_account_store_get_server_account (modest_runtime_get_account_store (),
TNY_ACCOUNT_TYPE_STORE);
if (!modest_account) {
- priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
MODEST_MAIL_OPERATION_ERROR_ITEM_NOT_FOUND,
"cannot get tny store account for %s\n", account_name);
- modest_mail_operation_notify_end (self);
-
- return FALSE;
+ goto error;
}
+
/* Get the transport account, we can not do it in the thread
due to some problems with dbus */
transport_account = (TnyTransportAccount *)
modest_tny_account_store_get_transport_account_for_open_connection (modest_runtime_get_account_store(),
account_name);
if (!transport_account) {
- priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
MODEST_MAIL_OPERATION_ERROR_ITEM_NOT_FOUND,
"cannot get tny transport account for %s\n", account_name);
- modest_mail_operation_notify_end (self);
-
- return FALSE;
+ goto error;
}
/* Create the helper object */
info->mail_op = self;
info->account = modest_account;
info->transport_account = transport_account;
+ info->callback = callback;
+ info->user_data = user_data;
/* Get the message size limit */
info->max_size = modest_conf_get_int (modest_runtime_get_conf (),
/* printf ("DEBUG: %s: info->retrieve_limit = %d\n", __FUNCTION__, info->retrieve_limit); */
+ /* Set account busy */
+ modest_account_mgr_set_account_busy(mgr, account_name, TRUE);
+ priv->account_name = g_strdup(account_name);
+
thread = g_thread_create (update_account_thread, info, FALSE, NULL);
return TRUE;
+
+ error:
+ priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
+ if (callback)
+ callback (self, 0, user_data);
+ modest_mail_operation_notify_end (self);
+ return FALSE;
}
/* ******************************************************************* */
helper = g_slice_new0 (GetMsgAsyncHelper);
helper->mail_op = self;
helper->user_callback = user_callback;
- helper->pending_ops = 1;
helper->user_data = user_data;
+ helper->header = g_object_ref (header);
tny_folder_get_msg_async (folder, header, get_msg_cb, get_msg_status_cb, helper);
self = helper->mail_op;
g_return_if_fail (MODEST_IS_MAIL_OPERATION(self));
priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
-
- helper->pending_ops--;
/* Check errors and cancel */
if (*error) {
/* If user defined callback function was defined, call it */
if (helper->user_callback) {
- helper->user_callback (self, NULL, msg, helper->user_data);
+ helper->user_callback (self, helper->header, msg, helper->user_data);
}
- /* Free */
out:
- if (helper->pending_ops == 0) {
- g_slice_free (GetMsgAsyncHelper, helper);
+ /* Free */
+ g_object_unref (helper->header);
+ g_slice_free (GetMsgAsyncHelper, helper);
- /* Notify about operation end */
- modest_mail_operation_notify_end (self);
- }
+ /* Notify about operation end */
+ modest_mail_operation_notify_end (self);
}
static void
priv->total = 1;
state = modest_mail_operation_clone_state (self);
+ state->bytes_done = status->position;
+ state->bytes_total = status->of_total;
g_signal_emit (G_OBJECT (self), signals[PROGRESS_CHANGED_SIGNAL], 0, state, NULL);
g_slice_free (ModestMailOperationState, state);
}
priv->status = MODEST_MAIL_OPERATION_STATUS_SUCCESS;
/* Notify about operation end */
- g_idle_add (notify_update_account_queue, info->mail_op);
+ g_idle_add (notify_update_account_queue, g_object_ref (info->mail_op));
/* Free thread resources. Will be called after all previous idles */
g_idle_add_full (G_PRIORITY_DEFAULT_IDLE + 1, get_msgs_full_destroyer, info, NULL);
GError **error,
gpointer user_data)
{
- ModestMailOperation *self;
- ModestMailOperationPrivate *priv;
+ RefreshAsyncHelper *helper = NULL;
+ ModestMailOperation *self = NULL;
+ ModestMailOperationPrivate *priv = NULL;
- self = MODEST_MAIL_OPERATION (user_data);
+ helper = (RefreshAsyncHelper *) user_data;
+ self = helper->mail_op;
priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
if (*error) {
priv->status = MODEST_MAIL_OPERATION_STATUS_SUCCESS;
out:
+ /* Call user defined callback, if it exists */
+ if (helper->user_callback)
+ helper->user_callback (priv->source, folder, helper->user_data);
+
/* Free */
+ g_object_unref (helper->mail_op);
+ g_slice_free (RefreshAsyncHelper, helper);
g_object_unref (folder);
/* Notify about operation end */
TnyStatus *status,
gpointer user_data)
{
- ModestMailOperation *self;
- ModestMailOperationPrivate *priv;
+ RefreshAsyncHelper *helper = NULL;
+ ModestMailOperation *self = NULL;
+ ModestMailOperationPrivate *priv = NULL;
ModestMailOperationState *state;
+ g_return_if_fail (user_data != NULL);
g_return_if_fail (status != NULL);
g_return_if_fail (status->code == TNY_FOLDER_STATUS_CODE_REFRESH);
- self = MODEST_MAIL_OPERATION (user_data);
+ helper = (RefreshAsyncHelper *) user_data;
+ self = helper->mail_op;
+ g_return_if_fail (MODEST_IS_MAIL_OPERATION(self));
+
priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
priv->done = status->position;
void
modest_mail_operation_refresh_folder (ModestMailOperation *self,
- TnyFolder *folder)
+ TnyFolder *folder,
+ RefreshAsyncUserCallback user_callback,
+ gpointer user_data)
{
- ModestMailOperationPrivate *priv;
+ ModestMailOperationPrivate *priv = NULL;
+ RefreshAsyncHelper *helper = NULL;
priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
/* Get account and set it into mail_operation */
priv->account = modest_tny_folder_get_account (folder);
+ /* Create the helper */
+ helper = g_slice_new0 (RefreshAsyncHelper);
+ helper->mail_op = g_object_ref(self);
+ helper->user_callback = user_callback;
+ helper->user_data = user_data;
+
/* Refresh the folder. TODO: tinymail could issue a status
updates before the callback call then this could happen. We
must review the design */
tny_folder_refresh_async (folder,
on_refresh_folder,
on_refresh_folder_status_update,
- self);
+ helper);
}
/**
modest_mail_operation_notify_end (ModestMailOperation *self)
{
ModestMailOperationState *state;
+ ModestMailOperationPrivate *priv = NULL;
+
+ g_return_if_fail (self);
+ priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
+
+ if (!priv) {
+ g_warning ("BUG: %s: priv == NULL", __FUNCTION__);
+ return;
+ }
+
+ /* Set the account back to not busy */
+ if (priv->account_name) {
+ modest_account_mgr_set_account_busy(modest_runtime_get_account_mgr(), priv->account_name,
+ FALSE);
+ g_free(priv->account_name);
+ priv->account_name = NULL;
+ }
+
/* Notify the observers about the mail opertation end */
state = modest_mail_operation_clone_state (self);
g_signal_emit (G_OBJECT (self), signals[PROGRESS_CHANGED_SIGNAL], 0, state, NULL);
projects / modest / blobdiff