#include <widgets/modest-window-mgr.h>
#include <modest-signal-mgr.h>
#include <modest-debug.h>
-
+#include "modest-utils.h"
#include <modest-defs.h>
#include "modest-tny-account-store.h"
#include "modest-tny-platform-factory.h"
#include <modest-platform.h>
#include "modest-ui-actions.h"
#include <widgets/modest-account-settings-dialog.h>
+#include <tny-camel-bs-msg-receive-strategy.h>
+#include <modest-tny-msg.h>
#ifdef MODEST_PLATFORM_MAEMO
#include <tny-maemo-conic-device.h>
static void insert_account (ModestTnyAccountStore *self,
const gchar *account,
- gboolean notify);
+ gboolean is_new);
static void on_account_removed (ModestAccountMgr *acc_mgr,
const gchar *account,
GnomeVFSVolume *volume,
gpointer user_data);
-static void forget_password_in_memory (ModestTnyAccountStore *self,
- const gchar *server_account_name);
-
static void add_connection_specific_transport_accounts (ModestTnyAccountStore *self);
static void remove_connection_specific_transport_accounts (ModestTnyAccountStore *self);
g_type_class_add_private (gobject_class,
sizeof(ModestTnyAccountStorePrivate));
}
-
+
static void
modest_tny_account_store_instance_init (ModestTnyAccountStore *obj)
{
priv->device = NULL;
priv->sighandlers = NULL;
priv->send_mail_blocked = FALSE;
-
+
priv->outbox_of_transport = g_hash_table_new_full (g_direct_hash,
g_direct_equal,
NULL,
g_object_unref (mmc_account);
} else {
- g_warning ("%s: there was no store account for the unmounted MMC",
- __FUNCTION__);
+ g_debug ("%s: there was no store account for the unmounted MMC",
+ __FUNCTION__);
}
}
g_free (volume_path_uri);
g_free (uri);
}
-/**
- * forget_password_in_memory
- * @self: a TnyAccountStore instance
- * @account: A server account.
- *
- * Forget any password stored in memory for this account.
- * For instance, this should be called when the user has changed the password in the account settings.
- */
-static void
-forget_password_in_memory (ModestTnyAccountStore *self,
+void
+modest_tny_account_store_forget_password_in_memory (ModestTnyAccountStore *self,
const gchar * server_account_name)
{
ModestTnyAccountStorePrivate *priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
- if (server_account_name && priv->password_hash) {
+ if (server_account_name && priv->password_hash)
g_hash_table_remove (priv->password_hash, server_account_name);
- }
}
static void
g_object_unref (iter);
}
-static void
-show_password_warning_only (const gchar *msg)
+static void
+show_wrong_password_dialog (TnyAccountStore *self,
+ TnyAccount *account,
+ gboolean show_banner)
{
- /* Show an explanatory temporary banner: */
- if (modest_window_mgr_get_num_windows (modest_runtime_get_window_mgr ()))
- modest_platform_information_banner (NULL, NULL, msg);
-}
+ TnyDevice *device;
+ gboolean is_online;
+
+ g_debug ("%s: %s", __FUNCTION__, tny_account_get_id (account));
+
+ device = tny_account_store_get_device (self);
+ is_online = tny_device_is_online (device);
+ g_object_unref (device);
+
+ if (!is_online) {
+ g_debug ("%s: not showing the acc settings dialog. Device OFFLINE", __FUNCTION__);
+ return;
+ }
+
+ if (modest_window_mgr_get_num_windows (modest_runtime_get_window_mgr ()) == 0) {
+ g_debug ("%s: not showing the account settings dialog. NO windows", __FUNCTION__);
+ return;
+ }
-static void
-show_wrong_password_dialog (TnyAccount *account,
- gboolean show_banner)
-{
if (g_object_get_data (G_OBJECT (account), "connection_specific") != NULL) {
modest_ui_actions_on_smtp_servers (NULL, NULL);
} else {
if (proto && MODEST_IS_ACCOUNT_PROTOCOL (proto)) {
ModestAccountSettingsDialog *dialog =
modest_account_protocol_get_account_settings_dialog (proto, modest_account_name);
- modest_window_mgr_set_modal (modest_runtime_get_window_mgr (), GTK_WINDOW (dialog), NULL);
- gtk_widget_show (GTK_WIDGET (dialog));
+
+ if (dialog) {
+ ModestWindowMgr *mgr = modest_runtime_get_window_mgr ();
+ GtkWindow *parent = modest_window_mgr_get_modal (mgr);
+ if (!parent)
+ parent = (GtkWindow *) modest_window_mgr_get_current_top (mgr);
+
+ modest_window_mgr_set_modal (mgr, GTK_WINDOW (dialog), parent);
+ gtk_widget_show (GTK_WIDGET (dialog));
+ }
}
}
/* Show an explanatory temporary banner: */
ModestTnyAccountStorePrivate *priv;
gchar *username = NULL;
gchar *pwd = NULL;
- gpointer pwd_ptr = NULL;
+ gpointer pwd_ptr;
gboolean already_asked = FALSE;
const gchar *server_account_name;
gchar *url_string;
g_return_val_if_fail (account, NULL);
-
- MODEST_DEBUG_BLOCK(
- g_debug ("%s: prompt (not shown) = %s\n", __FUNCTION__, prompt_not_used);
- );
+
+ g_debug ("%s: %s", __FUNCTION__, prompt_not_used);
/* Get a reference to myself */
self = MODEST_TNY_ACCOUNT_STORE (g_object_get_data (G_OBJECT(account), "account_store"));
server_account_name = tny_account_get_id (account);
if (!server_account_name || !self) {
- g_warning ("modest: %s: could not retrieve account_store for account %s",
+ g_warning ("%s: could not retrieve account_store for account %s",
__FUNCTION__, server_account_name ? server_account_name : "<NULL>");
if (cancel)
*cancel = TRUE;
return NULL;
}
+ /* We need to do this to avoid "dereferencing type-punned pointer will break strict-aliasing rules" */
+ pwd_ptr = (gpointer) &pwd;
+
/* This hash map stores passwords, including passwords that are not stored in gconf. */
/* Is it in the hash? if it's already there, it must be wrong... */
- pwd_ptr = (gpointer)&pwd; /* pwd_ptr so the compiler does not complained about
- * type-punned ptrs...*/
- already_asked = priv->password_hash &&
- g_hash_table_lookup_extended (priv->password_hash,
- server_account_name,
- NULL,
- (gpointer*)&pwd_ptr);
- MODEST_DEBUG_BLOCK(
- g_debug ("%s: Already asked = %d\n", __FUNCTION__, already_asked);
- );
+ already_asked = priv->password_hash && g_hash_table_lookup_extended (priv->password_hash,
+ server_account_name,
+ NULL,
+ pwd_ptr);
/* If the password is not already there, try ModestConf */
if (!already_asked) {
pwd = modest_account_mgr_get_server_account_password (priv->account_mgr,
server_account_name);
g_hash_table_insert (priv->password_hash, g_strdup (server_account_name), g_strdup (pwd));
+ } else {
+ /* We need to get it again because forget_password has cleared it */
+ pwd = modest_account_mgr_get_server_account_password (priv->account_mgr, server_account_name);
+ }
+
+ /* This is horrible but we need it until we don't get a proper
+ fix into tinymail. Thing is that tinymail incorrectly asks
+ for password when the connection to the server failed due a
+ timeout (slow network connection, firewalls...). In those
+ cases it makes no sense to ask the user. It's better just
+ to cancel cleanly */
+ if (g_strstr_len (prompt_not_used, -1, "Connection timed out")) {
+ g_debug ("%s, Incorrect get_password with connection issue", __FUNCTION__);
+ modest_tny_account_store_forget_password_in_memory (self, tny_account_get_id (account));
+ if (cancel)
+ *cancel = TRUE;
+ return NULL;
}
/* If it was already asked, it must have been wrong, so ask again */
gboolean settings_have_password;
ModestProtocolType protocol_type;
- /* As per the UI spec, if no password was set in the account settings,
- * ask for it now. But if the password is wrong in the account settings,
+ /* As per the UI spec, if no password was set in the account settings,
+ * ask for it now. But if the password is wrong in the account settings,
* then show a banner and the account settings dialog so it can be corrected:
*/
- settings_have_password =
+ settings_have_password =
modest_account_mgr_get_server_account_has_password (priv->account_mgr, server_account_name);
protocol_type = modest_tny_account_get_protocol_type (account);
password = modest_account_mgr_get_server_account_password (priv->account_mgr,
server_account_name);
- if (already_asked)
- msg = g_strdup (_("mcen_ib_username_pw_incorrect"));
- else if (!password || strlen(password) == 0)
+ if (!password || strlen(password) == 0) {
msg = g_strdup_printf (_("emev_ni_ui_smtp_passwd_invalid"),
tny_account_get_name (account),
tny_account_get_hostname (account));
- else
+ } else {
msg = g_strdup_printf (_("emev_ni_ui_smtp_authentication_fail_error"),
tny_account_get_hostname (account));
+ }
if (password)
g_free (password);
}
}
if (username)
g_free (username);
+ } else {
+ if (already_asked) {
+ const gchar *msg;
+ gboolean username_known =
+ modest_account_mgr_get_server_account_username_has_succeeded(priv->account_mgr,
+ server_account_name);
+ /* If the login has ever succeeded then show a specific message */
+ if (username_known)
+ msg = _CS ("ecdg_ib_set_password_incorrect");
+ else
+ msg = _("mcen_ib_username_pw_incorrect");
+ if (modest_window_mgr_get_num_windows (modest_runtime_get_window_mgr ()))
+ modest_platform_information_banner (NULL, NULL, msg);
+ }
}
if (settings_have_password) {
- /* The password must be wrong, so show the account settings dialog so it can be corrected: */
- show_wrong_password_dialog (account, TRUE);
+ if (pwd) {
+ /* The password must be wrong, so show
+ the account settings dialog so it
+ can be corrected: */
+ g_debug ("%s: going to show the settings dialog", __FUNCTION__);
+ show_wrong_password_dialog ((TnyAccountStore *) self, account, TRUE);
- if (cancel)
- *cancel = TRUE;
+ if (cancel)
+ *cancel = TRUE;
- return NULL;
+ return NULL;
+ } else {
+ /* Get the password from the account settings */
+ return modest_account_mgr_get_server_account_password (priv->account_mgr,
+ server_account_name);
+ }
}
/* we don't have it yet. Get the password from the user */
+ pwd = NULL;
const gchar* account_id = tny_account_get_id (account);
gboolean remember = FALSE;
- pwd = NULL;
-
- if (already_asked) {
- const gchar *msg;
- gboolean username_known =
- modest_account_mgr_get_server_account_username_has_succeeded(priv->account_mgr,
- server_account_name);
- /* If the login has ever succeeded then show a specific message */
- if (username_known)
- msg = _CS ("ecdg_ib_set_password_incorrect");
- else
- msg = _("mcen_ib_username_pw_incorrect");
- show_password_warning_only (msg);
- }
-
- /* Request password */
g_signal_emit (G_OBJECT (self), signals[PASSWORD_REQUESTED_SIGNAL], 0,
account_id, /* server_account_name */
&username, &pwd, cancel, &remember);
-
- if (!*cancel) {
- /* The password will be returned as the result,
- * but we need to tell tinymail about the username too: */
-
- /* WARNING: I disabled setting username as this can cause locks. Anyway,
- * as now we have the password dialog username entry always dimmed
- * this shouldn't be a problem */
-
- /* if (username) */
- /* tny_account_set_user (account, username); */
-
- /* Do not save the password in gconf, because
- * the UI spec says "The password will never
- * be saved in the account": */
-
- /* We need to dup the string even knowing that
- it's already a dup of the contents of an
- entry, because it if it's wrong, then camel
- will free it */
- g_hash_table_insert (priv->password_hash, g_strdup (server_account_name), g_strdup(pwd));
- } else {
+ if (*cancel) {
g_hash_table_remove (priv->password_hash, server_account_name);
-
g_free (pwd);
pwd = NULL;
}
g_free (username);
username = NULL;
- } else
+ } else {
if (cancel)
- *cancel = FALSE;
+ *cancel = FALSE;
+ }
return pwd;
}
(gpointer*)&pwd_ptr);
if (already_asked) {
- g_hash_table_remove (priv->password_hash, server_account_name);
+ g_hash_table_remove (priv->password_hash, server_account_name);
g_free (pwd);
pwd = NULL;
}
ModestTnyAccountStore *self;
ModestTnyAccountStorePrivate *priv;
const TnyAccountStore *account_store;
- gchar *pwd;
const gchar *key;
-
+ gchar *pwd;
+
account_store = TNY_ACCOUNT_STORE(g_object_get_data (G_OBJECT(account),
"account_store"));
self = MODEST_TNY_ACCOUNT_STORE (account_store);
have already asked for it at least once */
pwd = g_hash_table_lookup (priv->password_hash, key);
if (pwd) {
+ g_debug ("%s, forgetting %s for account %s", __FUNCTION__, pwd, key);
memset (pwd, 0, strlen (pwd));
g_hash_table_insert (priv->password_hash, g_strdup (key), NULL);
}
-
- /* Remove from configuration system */
- /*
- modest_account_mgr_unset (priv->account_mgr,
- key, MODEST_ACCOUNT_PASSWORD, TRUE);
- */
}
static void
g_free (priv->cache_dir);
priv->cache_dir = NULL;
-
+
if (priv->password_hash) {
g_hash_table_destroy (priv->password_hash);
priv->password_hash = NULL;
return result;
}
+static void _bodies_filter (TnyMsg *msg, TnyList *list)
+{
+ TnyMimePart *html_part, *text_part;
+
+ html_part = modest_tny_msg_find_body_part (msg, TRUE);
+ text_part = modest_tny_msg_find_body_part (msg, FALSE);
+
+ if (text_part && TNY_IS_MIME_PART (text_part) && html_part == text_part) {
+ g_object_unref (text_part);
+ text_part = NULL;
+ }
+
+ if (html_part && TNY_IS_MIME_PART (html_part)) {
+ tny_list_prepend (list, G_OBJECT (html_part));
+ g_object_unref (html_part);
+ }
+
+ if (text_part && TNY_IS_MIME_PART (text_part)) {
+ tny_list_prepend (list, G_OBJECT (text_part));
+ g_object_unref (text_part);
+ }
+}
+
+
ModestTnyAccountStore*
modest_tny_account_store_new (ModestAccountMgr *account_mgr,
TnyDevice *device)
TnyAccount *local_account = NULL;
TnyLockable *lockable;
GnomeVFSVolumeMonitor* monitor = NULL;
+ gboolean auto_update;
g_return_val_if_fail (account_mgr, NULL);
g_return_val_if_fail (device, NULL);
+ tny_camel_bs_msg_receive_strategy_set_global_bodies_filter (
+ (TnyCamelBsMsgReceiveStrategyBodiesFilter) _bodies_filter);
+
obj = G_OBJECT(g_object_new(MODEST_TYPE_TNY_ACCOUNT_STORE, NULL));
priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(obj);
priv->account_mgr = g_object_ref (G_OBJECT(account_mgr));
priv->device = g_object_ref (device);
+ /* If autoupdate is off then we don't try to connect to the
+ accounts when they're added to the account store*/
+ auto_update = modest_conf_get_bool (modest_runtime_get_conf (),
+ MODEST_CONF_AUTO_UPDATE, NULL);
+ if (!auto_update)
+ tny_device_force_offline (priv->device);
+
priv->session = tny_session_camel_new (TNY_ACCOUNT_STORE(obj));
if (!priv->session) {
g_warning ("failed to get TnySessionCamel");
priv->store_accounts_outboxes = tny_simple_list_new ();
/* Create the local folders account */
- local_account =
+ local_account =
modest_tny_account_new_for_local_folders (priv->account_mgr, priv->session, NULL);
tny_list_append (priv->store_accounts, G_OBJECT(local_account));
- g_object_unref (local_account);
+ g_object_unref (local_account);
/* Add the other remote accounts. Do this after adding the
local account, because we need to add our outboxes to the
global OUTBOX hosted in the local account */
add_existing_accounts (MODEST_TNY_ACCOUNT_STORE (obj));
-
+
/* Add connection-specific transport accounts if there are any
accounts available */
if (!only_local_accounts (MODEST_TNY_ACCOUNT_STORE(obj)))
add_connection_specific_transport_accounts (MODEST_TNY_ACCOUNT_STORE(obj));
-
+
/* This is a singleton, so it does not need to be unrefed. */
if (volume_path_is_mounted (g_getenv (MODEST_MMC1_VOLUMEPATH_ENV))) {
/* It is mounted: */
- add_mmc_account (MODEST_TNY_ACCOUNT_STORE (obj), FALSE /* don't emit the insert signal. */);
+ add_mmc_account (MODEST_TNY_ACCOUNT_STORE (obj), FALSE /* don't emit the insert signal. */);
}
-
+
+ /* Initialize session */
+ tny_session_camel_set_initialized (priv->session);
+
return MODEST_TNY_ACCOUNT_STORE(obj);
}
default:
g_return_if_reached ();
}
-
- /* Initialize session. Why do we need this ??? */
- tny_session_camel_set_initialized (priv->session);
}
gboolean retval = TRUE;
/* NOTE: account may be NULL in some cases */
- g_return_val_if_fail (error, FALSE);
-
+ if (!error)
+ return FALSE;
+
/* Get the server name: */
if (account) {
server_name = tny_account_get_hostname (account);
protocol_type = modest_tny_account_get_protocol_type (account);
if (protocol_type == MODEST_PROTOCOL_REGISTRY_TYPE_INVALID){
- g_warning("modest: %s: account with id=%s has no proto.\n", __FUNCTION__,
+ g_warning("%s: account with id=%s has no proto.\n", __FUNCTION__,
tny_account_get_id (account));
return FALSE;
}
g_return_val_if_reached (FALSE);
}
break;
-
case TNY_SERVICE_ERROR_AUTHENTICATE:
/* It seems that there's no better error to show with
* POP and IMAP because TNY_SERVICE_ERROR_AUTHENTICATE
g_return_val_if_reached (FALSE);
}
break;
-
case TNY_SERVICE_ERROR_CERTIFICATE:
/* We'll show the proper dialog later */
break;
case TNY_SYSTEM_ERROR_MEMORY:
/* Can't allocate memory for this operation */
-
- case TNY_SERVICE_ERROR_UNKNOWN:
+ if (modest_tny_account_store_check_disk_full_error ((ModestTnyAccountStore*)self,
+ NULL, error, account, NULL))
+ retval = FALSE;
+ break;
+ case TNY_SERVICE_ERROR_UNKNOWN:
return FALSE;
default:
- g_debug ("Unexpected error %d", error->code);
- g_return_val_if_reached (FALSE);
+ /* We don't treat this as an error, but as a not handled message. Then,
+ * debug message, and return false */
+ g_debug ("Unexpected error %d (%s)", error->code, error->message);
+ return FALSE;
}
else if (error->code == TNY_SERVICE_ERROR_AUTHENTICATE ||
error->code == TNY_SERVICE_ERROR_CONNECT) {
TnyDevice *device = modest_runtime_get_device ();
-
- modest_platform_run_information_dialog (NULL, prompt, TRUE);
-
- /* Show the account dialog. Checking the online status
- allows us to minimize the number of times that we
- incorrectly show the dialog */
- if (tny_device_is_online (device))
- show_wrong_password_dialog (account,
- (error->code == TNY_SERVICE_ERROR_CONNECT) ? FALSE : TRUE);
-
- retval = TRUE;
+ gboolean success;
+
+ /* If we get the connection error after establishing a
+ proper connection then do not show the dialog as we
+ are probably behind a firewall, or in a network
+ with connection issues. We just keep this code to
+ detect situations were the user does not enter the
+ server info properly */
+ success = modest_account_mgr_get_server_account_username_has_succeeded (modest_runtime_get_account_mgr (),
+ tny_account_get_id (account));
+
+ if (!success) {
+ gboolean show_banner;
+
+ g_debug ("%s: %s alert received (%s)", __FUNCTION__,
+ (error->code == TNY_SERVICE_ERROR_CONNECT) ? "connect" : "aunthenticate",
+ error->message);
+
+ if (tny_device_is_online (device) &&
+ modest_window_mgr_get_num_windows (modest_runtime_get_window_mgr ()))
+ modest_platform_run_information_dialog (NULL, prompt, TRUE);
+
+ /* Show the account dialog */
+ show_banner = (error->code == TNY_SERVICE_ERROR_CONNECT) ? FALSE : TRUE;
+ g_debug ("%s: going to show settings dialog", __FUNCTION__);
+ show_wrong_password_dialog (self, account, show_banner);
+ retval = TRUE;
+ }
}
g_debug ("%s: error code %d (%s", __FUNCTION__, error->code, error->message);
if (account) {
/* Forget any cached password for the account, so that
we use a new account if any */
- forget_password_in_memory (self, tny_account_get_id (account));
+ modest_tny_account_store_forget_password_in_memory (self, tny_account_get_id (account));
/* Set the account store */
g_object_set_data (G_OBJECT(account), "account_store", self);
static void
insert_account (ModestTnyAccountStore *self,
const gchar *account,
- gboolean notify)
+ gboolean is_new)
{
ModestTnyAccountStorePrivate *priv = NULL;
TnyAccount *store_account = NULL, *transport_account = NULL;
- ModestTnySendQueue *send_queue;
priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
/* Get the server and the transport account */
- store_account = create_tny_account (self, account, TNY_ACCOUNT_TYPE_STORE, notify);
+ store_account = create_tny_account (self, account, TNY_ACCOUNT_TYPE_STORE, is_new);
if (!store_account || !TNY_IS_ACCOUNT(store_account)) {
g_warning ("%s: failed to create store account", __FUNCTION__);
return;
}
- transport_account = create_tny_account (self, account, TNY_ACCOUNT_TYPE_TRANSPORT, notify);
+ transport_account = create_tny_account (self, account, TNY_ACCOUNT_TYPE_TRANSPORT, is_new);
if (!transport_account || !TNY_IS_ACCOUNT(transport_account)) {
g_warning ("%s: failed to create transport account", __FUNCTION__);
g_object_unref (store_account);
/* Create a new pseudo-account with an outbox for this
transport account and add it to the global outbox
in the local account */
- add_outbox_from_transport_account_to_global_outbox (self, account, transport_account);
+ add_outbox_from_transport_account_to_global_outbox (self, account, transport_account);
/* Force the creation of the send queue, this way send queues
will automatically send missing emails when the connections
become active */
- send_queue = modest_runtime_get_send_queue ((TnyTransportAccount *) transport_account, TRUE);
-
/* Notify the observers. We do it after everything is
created */
- if (notify) {
- g_signal_emit (G_OBJECT (self), signals [ACCOUNT_INSERTED_SIGNAL], 0, store_account);
+ if (is_new) {
+ /* We only have to do this for new accounts, already
+ existing accounts at boot time are instantiated by
+ modest_tny_account_store_start_send_queues */
+ modest_runtime_get_send_queue ((TnyTransportAccount *) transport_account, TRUE);
+
+ g_signal_emit (G_OBJECT (self), signals [ACCOUNT_INSERTED_SIGNAL], 0, store_account);
g_signal_emit (G_OBJECT (self), signals [ACCOUNT_INSERTED_SIGNAL], 0, transport_account);
}
gboolean add_specific;
add_specific = only_local_accounts (MODEST_TNY_ACCOUNT_STORE (user_data));
-
+
/* Insert the account and notify the observers */
insert_account (MODEST_TNY_ACCOUNT_STORE (user_data), account, TRUE);
with the configuration system this could not exist */
if (TNY_IS_STORE_ACCOUNT(store_account)) {
/* Forget any cached password for the account */
- forget_password_in_memory (self, tny_account_get_id (store_account));
+ modest_tny_account_store_forget_password_in_memory (self, tny_account_get_id (store_account));
/* Remove it from the list of accounts and notify the
observers. Do not need to wait for account
if (TNY_IS_TRANSPORT_ACCOUNT(transport_account)) {
/* Forget any cached password for the account */
- forget_password_in_memory (self, tny_account_get_id (transport_account));
+ modest_tny_account_store_forget_password_in_memory (self, tny_account_get_id (transport_account));
/* Remove transport account. It'll free the reference
added by get_server_account */
op_data->callback (op_data->account_store, op_data->userdata);
g_object_unref (op_data->account_store);
g_free (op_data);
- } else {
- g_object_unref (op_data->account_store);
}
}
g_return_if_fail (account && TNY_IS_ACCOUNT(account));
if (TNY_IS_STORE_ACCOUNT (account) &&
- !modest_tny_folder_store_is_remote (TNY_FOLDER_STORE (account)))
- goto frees;
-
- /* Disconnect account */
- if (tny_account_get_connection_status (account) == TNY_CONNECTION_STATUS_CONNECTED) {
- tny_camel_account_set_online (TNY_CAMEL_ACCOUNT(account), FALSE,
- account_shutdown_callback, op_data);
+ !modest_tny_folder_store_is_remote (TNY_FOLDER_STORE (account))) {
+ op_data->pending--;
return;
}
- frees:
- op_data->pending--;
- g_object_unref (op_data->account_store);
+ /* Disconnect account */
+ tny_camel_account_set_online (TNY_CAMEL_ACCOUNT(account), FALSE,
+ account_shutdown_callback, op_data);
+
}
ModestTnyAccountStoreShutdownCallback callback,
gpointer userdata)
{
- gint i, num_accounts;
+ gint num_accounts;
ShutdownOpData *op_data;
ModestTnyAccountStorePrivate *priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE (self);
if (priv->transport_accounts)
num_accounts += tny_list_get_length (priv->transport_accounts);
- for (i = 0 ; i < num_accounts ; i++)
- g_object_ref (self);
-
/* Create the helper object */
op_data = g_new0 (ShutdownOpData, 1);
op_data->callback = callback;
op_data->userdata = userdata;
op_data->pending = num_accounts;
- op_data->account_store = self;
+ op_data->account_store = g_object_ref (self);
+
+ /* Force the TnyDevice to be offline. This way new
+ undesired connections won't be initiated */
+ tny_device_force_offline (priv->device);
/* Destroy all accounts. Disconnect all accounts before they are destroyed */
if (priv->store_accounts) {
if (op_data->pending == 0) {
if (op_data->callback)
op_data->callback (op_data->account_store, op_data->userdata);
+ g_object_unref (op_data->account_store);
g_free (op_data);
}
}
gboolean
+modest_tny_account_store_is_shutdown (ModestTnyAccountStore *self)
+{
+ ModestTnyAccountStorePrivate *priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE (self);
+ TnyIterator *iter;
+ gboolean found;
+
+ found = FALSE;
+
+ for (iter = tny_list_create_iterator (priv->store_accounts);
+ !found && !tny_iterator_is_done (iter);
+ tny_iterator_next (iter)) {
+ TnyAccount *account;
+
+ account = (TnyAccount *) tny_iterator_get_current (iter);
+ if (TNY_IS_ACCOUNT (account)) {
+ found = (tny_account_get_connection_status (account) == TNY_CONNECTION_STATUS_CONNECTED) ||
+ (tny_account_get_connection_status (account) == TNY_CONNECTION_STATUS_RECONNECTING);
+ }
+ g_object_unref (account);
+ }
+ g_object_unref (iter);
+
+ if (found)
+ return !found;
+
+ for (iter = tny_list_create_iterator (priv->transport_accounts);
+ !found && !tny_iterator_is_done (iter);
+ tny_iterator_next (iter)) {
+ TnyAccount *account;
+
+ account = (TnyAccount *) tny_iterator_get_current (iter);
+ if (TNY_IS_ACCOUNT (account)) {
+ found = (tny_account_get_connection_status (account) == TNY_CONNECTION_STATUS_CONNECTED) ||
+ (tny_account_get_connection_status (account) == TNY_CONNECTION_STATUS_RECONNECTING);
+ }
+ g_object_unref (account);
+ }
+ g_object_unref (iter);
+
+ return !found;
+
+}
+
+
+gboolean
modest_tny_account_store_is_send_mail_blocked (ModestTnyAccountStore *self)
{
ModestTnyAccountStorePrivate *priv;
guint
modest_tny_account_store_get_num_remote_accounts (ModestTnyAccountStore *self)
{
- ModestTnyAccountStorePrivate *priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE (self);
+ ModestTnyAccountStorePrivate *priv;
gint count = 0;
+ g_return_val_if_fail (MODEST_IS_TNY_ACCOUNT_STORE (self), 0);
+
/* Count remote accounts */
+ priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE (self);
tny_list_foreach (priv->store_accounts, (GFunc) count_remote_accounts, &count);
return count;
}
+
+static void
+init_send_queue (TnyAccount *account, gpointer user_data)
+{
+ modest_runtime_get_send_queue ((TnyTransportAccount *) account, TRUE);
+}
+
+void
+modest_tny_account_store_start_send_queues (ModestTnyAccountStore *self)
+{
+ ModestTnyAccountStorePrivate *priv;
+ TnyList *tmp;
+
+ g_return_if_fail (MODEST_IS_TNY_ACCOUNT_STORE (self));
+
+ priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE (self);
+
+ /* We need to create a copy of the list because if the send
+ queues are created they'll directly access to the TnyList
+ of transport accounts, and thus we'll end up blocked in the
+ mutex the TnyList uses to synchronize accesses */
+ tmp = tny_list_copy (priv->transport_accounts);
+
+ /* Just instantiate them. They'll begin to listen for
+ connection changes to send messages ASAP */
+ tny_list_foreach (tmp, (GFunc) init_send_queue, NULL);
+ g_object_unref (tmp);
+}
+
+
+gboolean
+modest_tny_account_store_check_disk_full_error (ModestTnyAccountStore *self,
+ GtkWidget *parent_window,
+ GError *err,
+ TnyAccount *account,
+ const gchar *alternate)
+{
+ if (err == NULL)
+ return FALSE;
+
+ if (modest_tny_account_store_is_disk_full_error (self, err, account)) {
+ gboolean is_mcc = modest_tny_account_is_memory_card_account (account);
+ if (is_mcc && alternate) {
+ modest_platform_information_banner (parent_window, NULL, alternate);
+ } else {
+ gchar *msg = g_strdup_printf (_KR("cerm_device_memory_full"), "");
+ modest_platform_information_banner (parent_window, NULL, msg);
+ g_free (msg);
+ }
+ } else if (err->code == TNY_SYSTEM_ERROR_MEMORY)
+ /* If the account was created in memory full
+ conditions then tinymail won't be able to
+ connect so it'll return this error code */
+ modest_platform_information_banner (parent_window,
+ NULL, _("emev_ui_imap_inbox_select_error"));
+ else
+ return FALSE;
+
+ return TRUE;
+}
+
+gboolean
+modest_tny_account_store_is_disk_full_error (ModestTnyAccountStore *self,
+ GError *error,
+ TnyAccount *account)
+{
+ gboolean enough_free_space = TRUE;
+ GnomeVFSURI *cache_dir_uri;
+ const gchar *cache_dir = NULL;
+ GnomeVFSFileSize free_space;
+
+ /* Cache dir is different in case we're using an external storage (like MMC account) */
+ if (account && modest_tny_account_is_memory_card_account (account))
+ cache_dir = g_getenv (MODEST_MMC1_VOLUMEPATH_ENV);
+
+ /* Get the default local cache dir */
+ if (!cache_dir)
+ cache_dir = tny_account_store_get_cache_dir ((TnyAccountStore *) self);
+
+ cache_dir_uri = gnome_vfs_uri_new (cache_dir);
+ if (cache_dir_uri) {
+ if (gnome_vfs_get_volume_free_space (cache_dir_uri, &free_space) == GNOME_VFS_OK) {
+ if (free_space < MODEST_TNY_ACCOUNT_STORE_MIN_FREE_SPACE)
+ enough_free_space = FALSE;
+ }
+ gnome_vfs_uri_unref (cache_dir_uri);
+ }
+
+ if ((error->code == TNY_SYSTEM_ERROR_MEMORY ||
+ /* When asking for a mail and no space left on device
+ tinymail returns this error */
+ error->code == TNY_SERVICE_ERROR_MESSAGE_NOT_AVAILABLE ||
+ /* When the folder summary could not be read or
+ written */
+ error->code == TNY_IO_ERROR_WRITE ||
+ error->code == TNY_IO_ERROR_READ) &&
+ !enough_free_space) {
+ return TRUE;
+ } else {
+ return FALSE;
+ }
+}
projects / modest / blobdiff