#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;
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);
+ if (!priv) {
+ g_warning ("BUG: %s: priv == NULL", __FUNCTION__);
+ return FALSE;
+ }
- /* cancel current operation in account */
- tny_account_cancel (priv->account);
+ /* Notify about operation end */
+ modest_mail_operation_notify_end (self);
did_a_cancel = TRUE;
/* Set new status */
priv->status = MODEST_MAIL_OPERATION_STATUS_CANCELED;
+
+ modest_mail_operation_queue_cancel_all (modest_runtime_get_mail_operation_queue());
- /* Notify about operation end */
- 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);
/* 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 (folder) {
if (draft_msg != NULL) {
header = tny_msg_get_header (draft_msg);
+ /* 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 (folder, header, NULL);
g_object_unref (header);
}
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;
} 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);
return -1;
}
+static gboolean
+set_last_updated_idle (gpointer data)
+{
+ /* It does not matter if the time is not exactly the same than
+ the time when this idle was called, it's just an
+ approximation and it won't be very different */
+ modest_account_mgr_set_int (modest_runtime_get_account_mgr (),
+ (gchar *) data,
+ MODEST_ACCOUNT_LAST_UPDATED,
+ time(NULL),
+ TRUE);
+
+ return FALSE;
+}
+
static gpointer
update_account_thread (gpointer thr_user_data)
{
+ static gboolean first_time = TRUE;
UpdateAccountInfo *info;
TnyList *all_folders = NULL;
GPtrArray *new_headers;
/* 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 ();
* We use the blocking version, because we are already in a separate
* thread.
*/
- tny_folder_refresh (TNY_FOLDER (folder), &(priv->error));
- /* If the retrieve type is headers only do nothing more */
if (!g_ascii_strcasecmp (info->retrieve_type, MODEST_ACCOUNT_RETRIEVE_VALUE_MESSAGES) ||
!g_ascii_strcasecmp (info->retrieve_type, MODEST_ACCOUNT_RETRIEVE_VALUE_MESSAGES_AND_ATTACHMENTS)) {
TnyIterator *iter;
+ /* If the retrieve type is full messages, refresh and get the messages */
+ tny_folder_refresh (TNY_FOLDER (folder), &(priv->error));
+
iter = tny_list_create_iterator (observer->new_headers);
while (!tny_iterator_is_done (iter)) {
TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter));
priv->status = MODEST_MAIL_OPERATION_STATUS_SUCCESS;
/* Update the last updated key */
- modest_account_mgr_set_int (modest_runtime_get_account_mgr (),
- tny_account_get_id (TNY_ACCOUNT (info->account)),
- MODEST_ACCOUNT_LAST_UPDATED,
- time(NULL),
- TRUE);
+ g_idle_add_full (G_PRIORITY_HIGH_IDLE,
+ set_last_updated_idle,
+ g_strdup (tny_account_get_id (TNY_ACCOUNT (info->account))),
+ (GDestroyNotify) g_free);
}
out:
/* 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));
+
/* 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;
}
return FALSE;
}
+
/* Get the transport account, we can not do it in the thread
due to some problems with dbus */
transport_account = (TnyTransportAccount *)
/* 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;
helper = g_slice_new0 (GetMsgAsyncHelper);
helper->mail_op = self;
helper->user_callback = user_callback;
- helper->pending_ops = 1;
helper->user_data = user_data;
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) {
helper->user_callback (self, NULL, msg, helper->user_data);
}
- /* Free */
out:
- if (helper->pending_ops == 0) {
- g_slice_free (GetMsgAsyncHelper, helper);
+ /* Free */
+ 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->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