+ /* Update status and notify. We need to call the notification
+ with a source function in order to call it from the main
+ loop. We need that in order not to get into trouble with
+ Gtk+. We use a timeout in order to provide more status
+ information, because the sync tinymail call does not
+ provide it for the moment */
+ gint timeout = g_timeout_add (250, idle_notify_progress, info->mail_op);
+
+ /* Refresh folders */
+ new_headers = g_ptr_array_new ();
+ iter = tny_list_create_iterator (all_folders);
+
+ while (!tny_iterator_is_done (iter) && !priv->error && !did_a_cancel) {
+
+ InternalFolderObserver *observer;
+ TnyFolderStore *folder = TNY_FOLDER_STORE (tny_iterator_get_current (iter));
+
+ /* Refresh the folder */
+ /* Our observer receives notification of new emails during folder refreshes,
+ * so we can use observer->new_headers.
+ */
+ observer = g_object_new (internal_folder_observer_get_type (), NULL);
+ tny_folder_add_observer (TNY_FOLDER (folder), TNY_FOLDER_OBSERVER (observer));
+
+ /* This gets the status information (headers) from the server.
+ * We use the blocking version, because we are already in a separate
+ * thread.
+ */
+
+ 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));
+
+ /* Apply per-message size limits */
+ if (tny_header_get_message_size (header) < info->max_size)
+ g_ptr_array_add (new_headers, g_object_ref (header));
+
+ g_object_unref (header);
+ tny_iterator_next (iter);
+ }
+ g_object_unref (iter);
+ } 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;
+
+ g_object_unref (G_OBJECT (folder));
+ if (priv->error)
+ {
+ priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
+ goto out;
+ }
+
+ tny_iterator_next (iter);
+ }
+
+ did_a_cancel = FALSE;
+
+ g_object_unref (G_OBJECT (iter));
+ g_source_remove (timeout);
+
+ if (new_headers->len > 0) {
+ gint msg_num = 0;
+
+ /* Order by date */
+ g_ptr_array_sort (new_headers, (GCompareFunc) compare_headers_by_date);
+
+ /* Apply message count limit */
+ /* If the number of messages exceeds the maximum, ask the
+ * user to download them all,
+ * as per the UI spec "Retrieval Limits" section in 4.4:
+ */
+ 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. */
+ 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",
+ tny_account_get_name (TNY_ACCOUNT (info->transport_account)));
+ priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
+ goto out;
+ }
+
+ priv->done = 0;
+ priv->total = MIN (new_headers->len, info->retrieve_limit);
+ while (msg_num < priv->total) {
+
+ TnyHeader *header = TNY_HEADER (g_ptr_array_index (new_headers, msg_num));
+ TnyFolder *folder = tny_header_get_folder (header);
+ TnyMsg *msg = tny_folder_get_msg (folder, header, NULL);
+ ModestMailOperationState *state;
+ ModestPair* pair;
+
+ priv->done++;
+ /* We can not just use the mail operation because the
+ values of done and total could change before the
+ idle is called */
+ state = modest_mail_operation_clone_state (info->mail_op);
+ pair = modest_pair_new (g_object_ref (info->mail_op), state, FALSE);
+ g_idle_add_full (G_PRIORITY_HIGH_IDLE, idle_notify_progress_once,
+ pair, (GDestroyNotify) modest_pair_free);
+
+ g_object_unref (msg);
+ g_object_unref (folder);
+
+ msg_num++;
+ }
+ g_ptr_array_foreach (new_headers, (GFunc) g_object_unref, NULL);
+ g_ptr_array_free (new_headers, FALSE);
+ }
+
+ /* Perform send */
+ priv->op_type = MODEST_MAIL_OPERATION_TYPE_SEND;
+ priv->done = 0;
+ priv->total = 0;
+ if (priv->account != NULL)
+ g_object_unref (priv->account);
+ priv->account = g_object_ref (info->transport_account);
+
+ send_queue = modest_runtime_get_send_queue (info->transport_account);
+ if (send_queue) {
+ timeout = g_timeout_add (250, idle_notify_progress, info->mail_op);
+ modest_tny_send_queue_try_to_send (send_queue);
+ g_source_remove (timeout);
+ } else {
+ g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
+ MODEST_MAIL_OPERATION_ERROR_INSTANCE_CREATION_FAILED,
+ "cannot create a send queue for %s\n",
+ tny_account_get_name (TNY_ACCOUNT (info->transport_account)));
+ priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
+ }
+
+ /* Check if the operation was a success */
+ if (!priv->error) {
+ priv->status = MODEST_MAIL_OPERATION_STATUS_SUCCESS;
+
+ /* 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))),
+ (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 (idle_notify_update_account_queue, g_object_ref (info->mail_op));
+
+ if (info->callback) {
+ /* This thread is not in the main lock */
+ gdk_threads_enter ();
+ info->callback (info->mail_op,
+ (new_headers) ? new_headers->len : 0,
+ info->user_data);
+ gdk_threads_leave ();
+ }
+
+ /* Frees */
+ g_object_unref (query);
+ g_object_unref (all_folders);
+ g_object_unref (info->account);
+ g_object_unref (info->transport_account);
+ 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,
+ UpdateAccountCallback callback,
+ gpointer user_data)
+{
+ GThread *thread;
+ UpdateAccountInfo *info;
+ ModestMailOperationPrivate *priv;
+ ModestAccountMgr *mgr;
+ TnyStoreAccount *modest_account;
+ TnyTransportAccount *transport_account;
+
+ g_return_val_if_fail (MODEST_IS_MAIL_OPERATION (self), FALSE);
+ g_return_val_if_fail (account_name, 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 = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
+ 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 (),
+ account_name,
+ TNY_ACCOUNT_TYPE_STORE);
+
+ if (!modest_account) {
+ 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);
+ 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) {
+ 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);
+ goto error;
+ }
+
+ /* Create the helper object */
+ info = g_slice_new (UpdateAccountInfo);
+ 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 (),
+ MODEST_CONF_MSG_SIZE_LIMIT, NULL);
+ if (info->max_size == 0)
+ info->max_size = G_MAXINT;