+
+TnyAccount*
+modest_tny_account_store_get_mmc_folders_account (ModestTnyAccountStore *self)
+{
+ g_return_val_if_fail (MODEST_IS_TNY_ACCOUNT_STORE (self), NULL);
+
+ /* New reference */
+ return modest_tny_account_store_get_tny_account_by (self, MODEST_TNY_ACCOUNT_STORE_QUERY_ID,
+ MODEST_MMC_ACCOUNT_ID);
+
+}
+
+/*********************************************************************************/
+static void
+add_existing_accounts (ModestTnyAccountStore *self)
+{
+ GSList *account_names = NULL, *iter = NULL;
+ ModestTnyAccountStorePrivate *priv = NULL;
+
+ priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
+
+ /* These are account names, not server_account names */
+ account_names = modest_account_mgr_account_names (priv->account_mgr, FALSE);
+
+ for (iter = account_names; iter != NULL; iter = g_slist_next (iter)) {
+ const gchar *account_name = (const gchar*) iter->data;
+
+ /* Insert all enabled accounts without notifying */
+ if (modest_account_mgr_get_enabled (priv->account_mgr, account_name))
+ insert_account (self, account_name, FALSE);
+ }
+ modest_account_mgr_free_account_names (account_names);
+}
+
+static TnyAccount*
+create_tny_account (ModestTnyAccountStore *self,
+ const gchar *name,
+ TnyAccountType type,
+ gboolean notify)
+{
+ TnyAccount *account = NULL;
+ ModestTnyAccountStorePrivate *priv = NULL;
+
+ priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
+
+ account = modest_tny_account_new_from_account (priv->account_mgr,
+ name, type,
+ priv->session,
+ get_password,
+ forget_password);
+
+ 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));
+
+ /* Set the account store */
+ g_object_set_data (G_OBJECT(account), "account_store", self);
+ } else {
+ g_printerr ("modest: failed to create account for %s\n", name);
+ }
+
+ return account;
+}
+
+typedef struct _AddOutboxInfo {
+ ModestTnyAccountStore *account_store;
+ TnyAccount *transport_account;
+} AddOutboxInfo;
+
+static void
+add_outbox_from_transport_account_to_global_outbox_get_folders_cb (TnyFolderStore *folder_store,
+ gboolean cancelled,
+ TnyList *list,
+ GError *err,
+ gpointer userdata)
+{
+ TnyIterator *iter_folders;
+ TnyFolder *per_account_outbox;
+ TnyAccount *local_account = NULL;
+ AddOutboxInfo *info = (AddOutboxInfo *) userdata;
+ ModestTnyAccountStorePrivate *priv = NULL;
+ ModestTnyAccountStore *self;
+
+ self = MODEST_TNY_ACCOUNT_STORE (info->account_store);
+ priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
+
+ /* Note that this could happen if there is not enough space
+ available on disk, then the outbox folder could not be
+ created */
+ if (tny_list_get_length (list) != 1) {
+ g_warning ("%s: could not create outbox folder (%d folders found)", __FUNCTION__,
+ tny_list_get_length (list));
+ goto frees;
+ }
+
+ iter_folders = tny_list_create_iterator (list);
+ per_account_outbox = TNY_FOLDER (tny_iterator_get_current (iter_folders));
+ g_object_unref (iter_folders);
+ g_object_unref (list);
+
+ /* Add the outbox of the new per-account-local-outbox account
+ to the global local merged OUTBOX of the local folders
+ account */
+ local_account = modest_tny_account_store_get_local_folders_account (info->account_store);
+ modest_tny_local_folders_account_add_folder_to_outbox (MODEST_TNY_LOCAL_FOLDERS_ACCOUNT (local_account),
+ per_account_outbox);
+ /* Add the pair to the hash table */
+ g_hash_table_insert (priv->outbox_of_transport,
+ info->transport_account,
+ per_account_outbox);
+
+ /* Notify that the local account changed */
+ g_signal_emit (G_OBJECT (self), signals [ACCOUNT_CHANGED_SIGNAL], 0, local_account);
+ g_object_unref (local_account);
+ g_object_unref (per_account_outbox);
+
+ frees:
+ g_object_unref (info->transport_account);
+ g_slice_free (AddOutboxInfo, info);
+}
+
+
+static void
+add_outbox_from_transport_account_to_global_outbox (ModestTnyAccountStore *self,
+ const gchar *account_name,
+ TnyAccount *transport_account)
+{
+ TnyList *folders = NULL;
+ TnyAccount *account_outbox = NULL;
+ ModestTnyAccountStorePrivate *priv = NULL;
+ AddOutboxInfo *info;
+
+ priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
+
+ /* Create per account local outbox */
+ account_outbox =
+ modest_tny_account_new_for_per_account_local_outbox_folder (priv->account_mgr,
+ account_name,
+ priv->session);
+
+ if (!G_IS_OBJECT (account_outbox)) {
+ g_warning ("%s: could not create per account local outbox folder", __FUNCTION__);
+ return;
+ }
+
+ tny_list_append (priv->store_accounts_outboxes, G_OBJECT (account_outbox));
+
+ /* Get the outbox folder */
+ folders = tny_simple_list_new ();
+ info = g_slice_new0 (AddOutboxInfo);
+ info->account_store = self;
+ info->transport_account = g_object_ref (transport_account);
+ tny_folder_store_get_folders_async (TNY_FOLDER_STORE (account_outbox), folders, NULL, FALSE,
+ add_outbox_from_transport_account_to_global_outbox_get_folders_cb, NULL, (gpointer) info);
+ g_object_unref (account_outbox);
+}
+
+/*
+ * This function will be used for both adding new accounts and for the
+ * initialization. In the initialization we do not want to emit
+ * signals so notify will be FALSE, in the case of account additions
+ * we do want to notify the observers
+ */
+static void
+insert_account (ModestTnyAccountStore *self,
+ const gchar *account,
+ 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, 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, is_new);
+ if (!transport_account || !TNY_IS_ACCOUNT(transport_account)) {
+ g_warning ("%s: failed to create transport account", __FUNCTION__);
+ g_object_unref (store_account);
+ return;
+ }
+
+ /* 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);
+
+ /* 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 (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);
+ }
+
+ /* Frees */
+ g_object_unref (store_account);
+ g_object_unref (transport_account);
+}
+
+static inline gboolean
+only_local_accounts (ModestTnyAccountStore *self)
+{
+ return (modest_tny_account_store_get_num_remote_accounts (self) > 0) ? FALSE : TRUE;
+}
+
+static void
+on_account_inserted (ModestAccountMgr *acc_mgr,
+ const gchar *account,
+ gpointer user_data)
+{
+ 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);
+
+ /* If it's the first remote account then add the connection
+ specific SMTP servers as well */
+ if (add_specific)
+ add_connection_specific_transport_accounts (MODEST_TNY_ACCOUNT_STORE (user_data));
+
+}
+
+/* This is the callback of the tny_camel_account_set_online called in
+ on_account_removed to disconnect the account */
+static void
+on_account_disconnect_when_removing (TnyCamelAccount *account,
+ gboolean canceled,
+ GError *err,
+ gpointer user_data)
+{
+ ModestTnyAccountStore *self;
+ ModestTnyAccountStorePrivate *priv;
+
+ self = MODEST_TNY_ACCOUNT_STORE (user_data);
+ priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE (self);
+
+ /* Cancel all pending operations */
+ tny_account_cancel (TNY_ACCOUNT (account));
+
+ /* Unref the extra reference added by get_server_account */
+ g_object_unref (account);
+
+ /* Clear the cache if it's an store account */
+ if (TNY_IS_STORE_ACCOUNT (account)) {
+ tny_store_account_delete_cache (TNY_STORE_ACCOUNT (account));
+ } else if (TNY_IS_TRANSPORT_ACCOUNT (account)) {
+ ModestTnySendQueue* send_queue;
+ send_queue = modest_runtime_get_send_queue (TNY_TRANSPORT_ACCOUNT (account), FALSE);
+ if (TNY_IS_SEND_QUEUE (send_queue)) {
+ if (modest_tny_send_queue_sending_in_progress (send_queue))
+ tny_send_queue_cancel (TNY_SEND_QUEUE (send_queue),
+ TNY_SEND_QUEUE_CANCEL_ACTION_REMOVE,
+ NULL);
+ modest_runtime_remove_send_queue (TNY_TRANSPORT_ACCOUNT (account));
+ }
+ }
+}
+
+/*
+ * We use this one for both removing "normal" and "connection
+ * specific" transport accounts
+ */
+static void
+remove_transport_account (ModestTnyAccountStore *self,
+ TnyTransportAccount *transport_account)
+{
+ ModestTnyAccountStorePrivate *priv;
+ TnyFolder *outbox = NULL;
+
+ priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE (self);
+
+ /* Remove it from the list of accounts and notify the
+ observers. Do not need to wait for account
+ disconnection */
+ g_signal_emit (G_OBJECT (self), signals [ACCOUNT_REMOVED_SIGNAL], 0, transport_account);
+ tny_list_remove (priv->transport_accounts, (GObject *) transport_account);
+
+ /* Remove the OUTBOX of the account from the global outbox */
+ outbox = g_hash_table_lookup (priv->outbox_of_transport, transport_account);
+
+ if (TNY_IS_FOLDER (outbox)) {
+ TnyAccount *local_account = NULL;
+ TnyAccount *outbox_account = tny_folder_get_account (outbox);
+
+ if (outbox_account) {
+ tny_list_remove (priv->store_accounts_outboxes, G_OBJECT (outbox_account));
+ /* Remove existing emails to send */
+ tny_store_account_delete_cache (TNY_STORE_ACCOUNT (outbox_account));
+ g_object_unref (outbox_account);
+ }
+
+ local_account = modest_tny_account_store_get_local_folders_account (self);
+ modest_tny_local_folders_account_remove_folder_from_outbox (MODEST_TNY_LOCAL_FOLDERS_ACCOUNT (local_account),
+ outbox);
+
+ g_hash_table_remove (priv->outbox_of_transport, transport_account);
+
+ /* Notify the change in the local account */
+ g_signal_emit (G_OBJECT (self), signals [ACCOUNT_CHANGED_SIGNAL], 0, local_account);
+ g_object_unref (local_account);
+ } else {
+ g_warning ("Removing a transport account that has no outbox");
+ }
+
+ /* Cancel all pending operations */
+ tny_account_cancel (TNY_ACCOUNT (transport_account));
+
+ /* Disconnect and notify the observers. The callback will free the reference */
+ tny_camel_account_set_online (TNY_CAMEL_ACCOUNT (transport_account), FALSE,
+ on_account_disconnect_when_removing, self);
+}
+
+static gboolean
+images_cache_remove_filter (TnyStreamCache *self, const gchar *id, const gchar *account_name)
+{
+ gchar *account_name_with_separator;
+ gboolean result;
+ if (account_name == NULL || account_name[0] == '\0')
+ return FALSE;
+
+ if (id == NULL || id[0] == '\0')
+ return FALSE;
+
+ account_name_with_separator = g_strconcat (account_name, "__", NULL);
+
+ result = (g_str_has_prefix (id, account_name));
+ g_free (account_name_with_separator);
+
+ return result;
+}
+
+static void
+on_account_removed (ModestAccountMgr *acc_mgr,
+ const gchar *account,
+ gpointer user_data)
+{
+ TnyAccount *store_account = NULL, *transport_account = NULL;
+ ModestTnyAccountStore *self;
+ ModestTnyAccountStorePrivate *priv;
+ TnyStreamCache *stream_cache;
+
+ self = MODEST_TNY_ACCOUNT_STORE (user_data);
+ priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE (self);
+
+ /* Get the server and the transport account */
+ store_account =
+ modest_tny_account_store_get_server_account (self, account,
+ TNY_ACCOUNT_TYPE_STORE);
+ transport_account =
+ modest_tny_account_store_get_server_account (self, account,
+ TNY_ACCOUNT_TYPE_TRANSPORT);
+
+ /* If there was any problem creating the account, for example,
+ 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));
+
+ /* Remove it from the list of accounts and notify the
+ observers. Do not need to wait for account
+ disconnection */
+ tny_list_remove (priv->store_accounts, (GObject *) store_account);
+ g_signal_emit (G_OBJECT (self), signals [ACCOUNT_REMOVED_SIGNAL], 0, store_account);
+
+ /* Cancel all pending operations */
+ tny_account_cancel (TNY_ACCOUNT (store_account));
+
+ /* Disconnect before deleting the cache, because the
+ disconnection will rewrite the cache to the
+ disk */
+ tny_camel_account_set_online (TNY_CAMEL_ACCOUNT (store_account), FALSE,
+ on_account_disconnect_when_removing, self);
+ } else {
+ g_warning ("%s: no store account for account %s\n",
+ __FUNCTION__, account);
+ }
+
+ /* If there was any problem creating the account, for example,
+ with the configuration system this could not exist */
+ 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));
+
+ /* Remove transport account. It'll free the reference
+ added by get_server_account */
+ remove_transport_account (self, TNY_TRANSPORT_ACCOUNT (transport_account));
+ } else {
+ g_warning ("%s: no transport account for account %s\n",
+ __FUNCTION__, account);
+ }
+
+ /* Remove cached images */
+ stream_cache = modest_runtime_get_images_cache ();
+ tny_stream_cache_remove (stream_cache, (TnyStreamCacheRemoveFilter) images_cache_remove_filter, (gpointer) account);
+
+ /* If there are no more user accounts then delete the
+ transport specific SMTP servers */
+ if (only_local_accounts (self))
+ remove_connection_specific_transport_accounts (self);
+}
+
+TnyTransportAccount *
+modest_tny_account_store_new_connection_specific_transport_account (ModestTnyAccountStore *self,
+ const gchar *name)
+{
+ ModestTnyAccountStorePrivate *priv = NULL;
+ TnyAccount * tny_account = NULL;
+
+ priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
+
+ /* Add the account: */
+ tny_account =
+ modest_tny_account_new_from_server_account_name (priv->account_mgr,
+ priv->session,
+ name,
+ get_password,
+ forget_password);
+ if (tny_account) {
+ g_object_set_data (G_OBJECT(tny_account),
+ "account_store",
+ (gpointer)self);
+ g_object_set_data (G_OBJECT(tny_account),
+ "connection_specific",
+ GINT_TO_POINTER (TRUE));
+
+ tny_list_append (priv->transport_accounts, G_OBJECT (tny_account));
+ add_outbox_from_transport_account_to_global_outbox (self,
+ name,
+ tny_account);
+
+ } else
+ g_printerr ("modest: failed to create smtp-specific account for %s\n",
+ name);
+
+ return TNY_TRANSPORT_ACCOUNT (tny_account);
+}
+
+static void
+foreach_free_string(gpointer data,
+ gpointer user_data)
+{
+ g_free (data);
+}
+
+static void
+add_connection_specific_transport_accounts (ModestTnyAccountStore *self)
+{
+ ModestTnyAccountStorePrivate *priv = NULL;
+ GSList *list_specifics = NULL, *iter = NULL;
+ GError *err = NULL;
+
+ priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
+
+ list_specifics = modest_conf_get_list (modest_runtime_get_conf (),
+ MODEST_CONF_CONNECTION_SPECIFIC_SMTP_LIST,
+ MODEST_CONF_VALUE_STRING, &err);
+ if (err) {
+ g_error_free (err);
+ g_return_if_reached ();
+ return;
+ }
+
+ /* Look at each connection-specific transport account for the
+ * modest account: */
+ iter = list_specifics;
+ while (iter) {
+ /* The list alternates between the connection name and the transport name: */
+ iter = g_slist_next (iter);
+ if (iter) {
+ const gchar* transport_account_name = (const gchar*) (iter->data);
+ TnyTransportAccount * account = NULL;
+ account = modest_tny_account_store_new_connection_specific_transport_account (
+ self, transport_account_name);
+ if (account)
+ g_object_unref (account);
+ }
+ iter = g_slist_next (iter);
+ }
+
+ /* Free the list */
+ g_slist_foreach (list_specifics, foreach_free_string, NULL);
+ g_slist_free (list_specifics);
+}
+
+static void
+remove_connection_specific_transport_accounts (ModestTnyAccountStore *self)
+{
+ ModestTnyAccountStorePrivate *priv = NULL;
+ GSList *list_specifics = NULL, *iter = NULL;
+ GError *err = NULL;
+
+ priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
+
+ err = NULL;
+ list_specifics = modest_conf_get_list (modest_runtime_get_conf (),
+ MODEST_CONF_CONNECTION_SPECIFIC_SMTP_LIST,
+ MODEST_CONF_VALUE_STRING, &err);
+ if (err) {
+ g_error_free (err);
+ g_return_if_reached ();
+ return;
+ }
+
+ /* Look at each connection-specific transport account for the
+ * modest account: */
+ iter = list_specifics;
+ while (iter) {
+ /* The list alternates between the connection name and the transport name: */
+ iter = g_slist_next (iter);
+ if (iter) {
+ const gchar* transport_account_name = (const gchar*) (iter->data);
+ TnyAccount * account;
+ account = modest_tny_account_store_get_server_account (self,
+ transport_account_name,
+ TNY_ACCOUNT_TYPE_TRANSPORT);
+
+ /* the call will free the reference */
+ if (account)
+ remove_transport_account (self, TNY_TRANSPORT_ACCOUNT (account));
+ }
+ iter = g_slist_next (iter);
+ }
+
+ /* Free the list */
+ g_slist_foreach (list_specifics, foreach_free_string, NULL);
+ g_slist_free (list_specifics);
+}
+
+
+TnyMsg *
+modest_tny_account_store_find_msg_in_outboxes (ModestTnyAccountStore *self,
+ const gchar *uri,
+ TnyAccount **ac_out)
+{
+ TnyIterator *acc_iter;
+ ModestTnyAccountStorePrivate *priv;
+ TnyMsg *msg = NULL;
+ TnyAccount *msg_account = NULL;
+
+ g_return_val_if_fail (MODEST_IS_TNY_ACCOUNT_STORE (self), NULL);
+ priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE (self);
+
+ acc_iter = tny_list_create_iterator (priv->store_accounts_outboxes);
+ while (!msg && !tny_iterator_is_done (acc_iter)) {
+ TnyList *folders = tny_simple_list_new ();
+ TnyAccount *account = TNY_ACCOUNT (tny_iterator_get_current (acc_iter));
+ TnyIterator *folders_iter = NULL;
+
+ tny_folder_store_get_folders (TNY_FOLDER_STORE (account), folders, NULL, FALSE, NULL);
+ folders_iter = tny_list_create_iterator (folders);
+
+ while (msg == NULL && !tny_iterator_is_done (folders_iter)) {
+ TnyFolder *folder = TNY_FOLDER (tny_iterator_get_current (folders_iter));
+ msg = tny_folder_find_msg (folder, uri, NULL);
+
+ if (msg)
+ msg_account = g_object_ref (account);
+
+ g_object_unref (folder);
+ tny_iterator_next (folders_iter);
+ }
+ g_object_unref (folders_iter);
+
+ g_object_unref (folders);
+ g_object_unref (account);
+ tny_iterator_next (acc_iter);
+ }
+
+ g_object_unref (acc_iter);
+
+ if (ac_out != NULL)
+ *ac_out = msg_account;
+
+ return msg;
+}
+
+TnyTransportAccount *
+modest_tny_account_store_get_transport_account_from_outbox_header(ModestTnyAccountStore *self, TnyHeader *header)
+{
+ TnyIterator *acc_iter;
+ ModestTnyAccountStorePrivate *priv;
+ TnyTransportAccount *header_acc = NULL;
+ gchar *msg_id;
+
+ g_return_val_if_fail (MODEST_IS_TNY_ACCOUNT_STORE (self), NULL);
+ g_return_val_if_fail (TNY_IS_HEADER (header), NULL);
+ priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE (self);
+ msg_id = modest_tny_send_queue_get_msg_id (header);
+ acc_iter = tny_list_create_iterator (priv->transport_accounts);
+ while (!header_acc && !tny_iterator_is_done (acc_iter)) {
+ TnyTransportAccount *account = TNY_TRANSPORT_ACCOUNT (tny_iterator_get_current (acc_iter));
+ ModestTnySendQueue *send_queue;
+ ModestTnySendQueueStatus status;
+ send_queue = modest_runtime_get_send_queue(TNY_TRANSPORT_ACCOUNT(account), TRUE);
+ if (TNY_IS_SEND_QUEUE (send_queue)) {
+ status = modest_tny_send_queue_get_msg_status(send_queue, msg_id);
+ if (status != MODEST_TNY_SEND_QUEUE_UNKNOWN)
+ header_acc = g_object_ref(account);
+ }
+ g_object_unref (account);
+ tny_iterator_next (acc_iter);
+ }
+ g_object_unref(acc_iter);
+ g_free (msg_id);
+
+ /* New reference */
+ return header_acc;
+}
+
+typedef struct {
+ ModestTnyAccountStore *account_store;
+ ModestTnyAccountStoreShutdownCallback callback;
+ gpointer userdata;
+ gint pending;
+} ShutdownOpData;
+
+static void
+account_shutdown_callback (TnyCamelAccount *account, gboolean canceled, GError *err, gpointer userdata)
+{
+ ShutdownOpData *op_data = (ShutdownOpData *) userdata;
+ op_data->pending--;
+ 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);
+ }
+}
+
+static void
+account_shutdown (TnyAccount *account, ShutdownOpData *op_data)
+{
+ 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))) {
+ op_data->pending--;
+ return;
+ }
+
+ /* Disconnect account */
+ tny_camel_account_set_online (TNY_CAMEL_ACCOUNT(account), FALSE,
+ account_shutdown_callback, op_data);
+
+}
+
+
+void
+modest_tny_account_store_shutdown (ModestTnyAccountStore *self,
+ ModestTnyAccountStoreShutdownCallback callback,
+ gpointer userdata)
+{
+ gint num_accounts;
+ ShutdownOpData *op_data;
+ ModestTnyAccountStorePrivate *priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE (self);
+
+ /* Get references */
+ num_accounts = 0;
+ if (priv->store_accounts)
+ num_accounts += tny_list_get_length (priv->store_accounts);
+ if (priv->transport_accounts)
+ num_accounts += tny_list_get_length (priv->transport_accounts);
+
+ /* 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 = 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) {
+ tny_list_foreach (priv->store_accounts, (GFunc)account_shutdown, op_data);
+ }
+
+ if (priv->transport_accounts) {
+ tny_list_foreach (priv->transport_accounts, (GFunc)account_shutdown, op_data);
+ }
+
+ 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;
+
+ priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
+
+ return priv->send_mail_blocked;
+}
+
+void
+modest_tny_account_store_set_send_mail_blocked (ModestTnyAccountStore *self,
+ gboolean blocked)
+{
+ ModestTnyAccountStorePrivate *priv;
+
+ priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
+
+ priv->send_mail_blocked = blocked;
+}
+
+static void
+count_remote_accounts (gpointer data, gpointer user_data)
+{
+ TnyFolderStore *account = TNY_FOLDER_STORE (data);
+ gint *count = (gint *) user_data;
+
+ if (modest_tny_folder_store_is_remote (account))
+ (*count)++;
+}
+
+guint
+modest_tny_account_store_get_num_remote_accounts (ModestTnyAccountStore *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;
+ }
+}
+
+void
+modest_tny_account_store_reset_attempt_count (ModestTnyAccountStore *self,
+ TnyAccount *account)
+{
+ ModestTnyAccountStorePrivate *priv;
+ PwdAttempt *attempt;
+
+ priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
+
+ /* Reset the count */
+ attempt = g_hash_table_lookup (priv->password_hash, tny_account_get_id (account));
+ if (attempt) {
+ attempt->count = RETRY_ATTEMPTS;
+ g_debug ("%s, reseting the attempt count for account %s", __FUNCTION__, tny_account_get_id (account));
+ }
+}