#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"
static void modest_tny_account_store_init (gpointer g, gpointer iface_data);
static void modest_tny_account_store_base_init (gpointer g_class);
-static void on_account_inserted (ModestAccountMgr *acc_mgr,
+static void on_account_inserted (ModestAccountMgr *acc_mgr,
const gchar *account,
gpointer user_data);
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,
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);
}
static void
-show_password_warning_only (const gchar *msg)
-{
- /* Show an explanatory temporary banner: */
- if (modest_window_mgr_get_num_windows (modest_runtime_get_window_mgr ()))
- modest_platform_information_banner (NULL, NULL, msg);
-}
-
-static void
show_wrong_password_dialog (TnyAccount *account,
gboolean show_banner)
{
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;
if (modest_protocol_registry_protocol_type_has_tag(modest_runtime_get_protocol_registry (),
protocol_type, MODEST_PROTOCOL_REGISTRY_TRANSPORT_PROTOCOLS)) {
gchar *username = NULL, *msg = NULL;
+ gboolean is_banner = FALSE;
username = modest_account_mgr_get_server_account_username (priv->account_mgr,
server_account_name);
if (!username || strlen(username) == 0) {
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 (already_asked) {
+ msg = g_strdup (_CS("ecdg_ib_set_password_incorrect"));
+ is_banner = TRUE;
+ } else 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 (msg) {
- modest_platform_run_information_dialog (NULL, msg, TRUE);
+ if (is_banner)
+ modest_platform_information_banner (NULL, NULL, msg);
+ else
+ modest_platform_run_information_dialog (NULL, msg, TRUE);
g_free (msg);
}
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) {
}
/* 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: */
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. */);
}
-
+
return MODEST_TNY_ACCOUNT_STORE(obj);
}
/* NOTE: account may be NULL in some cases */
g_return_val_if_fail (error, 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;
}
static void
insert_account (ModestTnyAccountStore *self,
const gchar *account,
- gboolean notify)
+ gboolean is_new)
{
ModestTnyAccountStorePrivate *priv = NULL;
TnyAccount *store_account = NULL, *transport_account = NULL;
-
+
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);
/* Add accounts to the lists */
tny_list_append (priv->store_accounts, G_OBJECT (store_account));
tny_list_append (priv->transport_accounts, G_OBJECT (transport_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 */
/* 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);
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