1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the Qt Mobility Components.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 #include "modestengine_maemo_p.h"

    42 #include "maemohelpers_p.h"

    43 #include "qmessage_p.h"

    44 #include "qmessageaccount.h"

    45 #include "qmessageaccount_p.h"

    46 #include "qmessageaccountfilter.h"

    47 #include "qmessageaccountfilter_p.h"

    48 #include "qmessagefolder_p.h"

    49 #include "qmessagestore_p.h"

    50 #include "qmessageservice_maemo_p.h"

    51 #include "qmessagecontentcontainer_maemo_p.h"

    52 #include <QUrl>

    53 #include <QtDBus>

    54 #include <QFileSystemWatcher>

    55 #include <QTimer>

    56 

    57 #include <dbus/dbus.h>

    58 #include <QDebug>

    59 

    60 #include </usr/include/libmodest-dbus-client-1.0/libmodest-dbus-client/libmodest-dbus-api.h>

    61 #include </usr/include/sys/inotify.h>

    62 #include </usr/include/sys/ioctl.h>

    63 #include </usr/include/sys/fcntl.h>

    64 

    65 // Marshall the ModestStringMap data into a D-Bus argument

    66 QDBusArgument &operator<<(QDBusArgument &argument,

    67                           const QtMobility::ModestStringMap &map)

    68 {

    69     QtMobility::ModestStringMap::const_iterator iter;

    70 

    71     argument.beginMap (QVariant::String, QVariant::String);

    72     for (iter = map.constBegin(); iter != map.constEnd(); iter++) {

    73         argument.beginMapEntry();

    74         argument << iter.key() << iter.value();

    75         argument.endMapEntry();

    76     }

    77     argument.endMap();

    78 

    79     return argument;

    80 }

    81 

    82 // Retrieve the ModestStringMap data from the D-Bus argument

    83 const QDBusArgument &operator>>(const QDBusArgument &argument,

    84                                 QtMobility::ModestStringMap &map)

    85 {

    86     map.clear();

    87 

    88     argument.beginMap();

    89     while (!argument.atEnd()) {

    90         QString key, value;

    91         argument.beginMapEntry();

    92         argument >> key >> value;

    93         argument.endMapEntry();

    94         map[key] = value;

    95     }

    96     argument.endMap();

    97 

    98     return argument;

    99 }

   100 

   101 QDBusArgument &operator<<(QDBusArgument &argument,

   102                           const QtMobility::ModestUnreadMessageDBusStruct &unreadMessage)

   103 {

   104     argument.beginStructure();

   105     argument << unreadMessage.timeStamp;

   106     argument << unreadMessage.subject;

   107     argument.endStructure();

   108     return argument;

   109 }

   110 

   111 const QDBusArgument &operator>>(const QDBusArgument &argument,

   112                                 QtMobility::ModestUnreadMessageDBusStruct &unreadMessage)

   113 {

   114     argument.beginStructure();

   115     argument >> unreadMessage.timeStamp;

   116     argument >> unreadMessage.subject;

   117     argument.endStructure();

   118     return argument;

   119 }

   120 

   121 QDBusArgument &operator<<(QDBusArgument &argument,

   122                           const QtMobility::ModestAccountsUnreadMessagesDBusStruct &unreadMessages)

   123 {

   124     argument.beginStructure();

   125     argument << unreadMessages.accountId;

   126     argument << unreadMessages.accountName;

   127     argument << unreadMessages.accountProtocol;

   128     argument << unreadMessages.unreadCount;

   129     argument << unreadMessages.unreadMessages;

   130     argument.endStructure();

   131     return argument;

   132 }

   133 

   134 const QDBusArgument &operator>>(const QDBusArgument &argument,

   135                                 QtMobility::ModestAccountsUnreadMessagesDBusStruct &unreadMessages)

   136 {

   137     argument.beginStructure();

   138     argument >> unreadMessages.accountId;

   139     argument >> unreadMessages.accountName;

   140     argument >> unreadMessages.accountProtocol;

   141     argument >> unreadMessages.unreadCount;

   142     argument >> unreadMessages.unreadMessages;

   143     argument.endStructure();

   144     return argument;

   145 }

   146 

   147 QDBusArgument &operator<<(QDBusArgument &argument, const QtMobility::ModestMessage &message)

   148 {

   149     argument.beginStructure();

   150     argument << message.id;

   151     argument << message.subject;

   152     argument << message.folder;

   153     argument << message.sender;

   154     argument << message.size;

   155     argument << message.hasAttachment;

   156     argument << message.isUnread;

   157     argument << message.timeStamp;

   158     argument.endStructure();

   159     return argument;

   160 }

   161 

   162 const QDBusArgument &operator>>(const QDBusArgument &argument, QtMobility::ModestMessage &message)

   163 {

   164     argument.beginStructure();

   165     argument >> message.id;

   166     argument >> message.subject;

   167     argument >> message.folder;

   168     argument >> message.sender;

   169     argument >> message.size;

   170     argument >> message.hasAttachment;

   171     argument >> message.isUnread;

   172     argument >> message.timeStamp;

   173     argument.endStructure();

   174     return argument;

   175 }

   176 

   177 QDBusArgument &operator<<(QDBusArgument &argument, const QtMobility::MessagingModestMimePart &mimePart)

   178 {

   179     argument.beginStructure();

   180     argument << mimePart.mimeType;

   181     argument << mimePart.isAttachment;

   182     argument << mimePart.fileName;

   183     argument << mimePart.contentId;

   184     argument.endStructure();

   185     return argument;

   186 }

   187 

   188 const QDBusArgument &operator>>(const QDBusArgument &argument, QtMobility::MessagingModestMimePart &mimePart)

   189 {

   190     argument.beginStructure();

   191     argument >> mimePart.mimeType;

   192     argument >> mimePart.isAttachment;

   193     argument >> mimePart.fileName;

   194     argument >> mimePart.contentId;

   195     argument.endStructure();

   196     return argument;

   197 }

   198 

   199 QDBusArgument &operator<<(QDBusArgument &argument, const QtMobility::MessagingModestFolder &folder)

   200 {

   201     argument.beginStructure();

   202     argument << folder.parentAccountId;

   203     argument << folder.parentFolderId;

   204     argument << folder.modestId;

   205     argument << static_cast<uint>(folder.type);

   206     argument << folder.localizedName;

   207     argument.endStructure();

   208     return argument;

   209 }

   210 

   211 const QDBusArgument &operator>>(const QDBusArgument &argument, QtMobility::MessagingModestFolder &folder)

   212 {

   213     argument.beginStructure();

   214 

   215     argument >> folder.parentAccountId;

   216     QByteArray str = folder.parentAccountId.toUtf8();

   217     gchar* escaped_string = gconf_escape_key(str.data(), str.length());

   218     folder.parentAccountId = QString::fromUtf8(escaped_string);

   219     g_free(escaped_string);

   220 

   221     argument >> folder.parentFolderId;

   222     argument >> folder.modestId;

   223 

   224     uint type;

   225     argument >> type;

   226     folder.type = static_cast<QtMobility::MessagingModestFolderType>(type);

   227 

   228     argument >> folder.localizedName;

   229     argument.endStructure();

   230     return argument;

   231 }

   232 

   233 QTM_BEGIN_NAMESPACE

   234 

   235 /* configuration key definitions for modest */

   236 #define MODESTENGINE_ACCOUNT_NAMESPACE         "/apps/modest/accounts"

   237 #define MODESTENGINE_SERVER_ACCOUNT_NAMESPACE  "/apps/modest/server_accounts"

   238 #define MODESTENGINE_DEFAULT_ACCOUNT           "/apps/modest/default_account"

   239 #define MODESTENGINE_ACCOUNT_ENABLED           "enabled"

   240 #define MODESTENGINE_ACCOUNT_DISPLAY_NAME      "display_name"

   241 #define MODESTENGINE_ACCOUNT_FULLNAME          "fullname"

   242 #define MODESTENGINE_ACCOUNT_EMAIL             "email"

   243 #define MODESTENGINE_ACCOUNT_STORE_ACCOUNT     "store_account"

   244 #define MODESTENGINE_ACCOUNT_TRANSPORT_ACCOUNT "transport_account"

   245 #define MODESTENGINE_ACCOUNT_PROTOCOL          "proto"

   246 #define MODESTENGINE_ACCOUNT_USERNAME          "username"

   247 #define MODESTENGINE_ACCOUNT_HOSTNAME          "hostname"

   248 #define MODESTENGINE_ACCOUNT_PORT              "port"

   249 

   250 // The modest engine has a new plugin, we need service names for it

   251 #define MODESTENGINE_QTM_PLUGIN_PATH           "/com/nokia/Qtm/Modest/Plugin"

   252 #define MODESTENGINE_QTM_PLUGIN_NAME           "com.nokia.Qtm.Modest.Plugin"

   253 

   254 typedef enum {

   255     MODEST_DBUS_SEARCH_SUBJECT   = (1 << 0),

   256     MODEST_DBUS_SEARCH_SENDER    = (1 << 1),

   257     MODEST_DBUS_SEARCH_RECIPIENT = (1 << 2),

   258     MODEST_DBUS_SEARCH_SIZE      = (1 << 3),

   259     MODEST_DBUS_SEARCH_BODY      = (1 << 6)

   260 } ModestDBusSearchFlags;

   261 

   262 // Specific priority settings to translate to modest priorities

   263 #define MODESTENGINE_HIGH_PRIORITY             2

   264 #define MODESTENGINE_NORMAL_PRIORITY           0

   265 #define MODESTENGINE_LOW_PRIORITY              1

   266 

   267 Q_GLOBAL_STATIC(ModestEngine,modestEngine);

   268 

   269 ModestEngine::ModestEngine()

   270  : m_queryIds(0)

   271 {

   272     qWarning() << "ModestEngine::ModestEngine Starting to initialize";

   273     g_type_init();

   274     m_gconfclient = gconf_client_get_default();

   275     if (!m_gconfclient) {

   276         qWarning("qtmessaging: could not get gconf client");

   277     } else {

   278         updateEmailAccounts();

   279     }

   280 

   281     qWarning() << "ModestEngine::ModestEngine Connecting to Modest DBus Interface";

   282     // Setup DBus Interface for Modest

   283     m_ModestDBusInterface = new QDBusInterface(MODEST_DBUS_SERVICE,

   284                                                MODEST_DBUS_OBJECT,

   285                                                MODEST_DBUS_IFACE,

   286                                                QDBusConnection::sessionBus(),

   287                                                this);

   288     if (m_ModestDBusInterface->isValid()) {

   289         qWarning() << "ModestEngine::ModestEngine Connected to Modest DBus Interface";

   290     } else {

   291         qWarning() << "ModestEngine::ModestEngine Unable to connect to Modest DBus Interface";

   292     }

   293 

   294     // Get notifications of Incoming Messages

   295     m_ModestDBusInterface->connection().connect(MODEST_DBUS_SERVICE,

   296                                                 MODEST_DBUS_OBJECT,

   297                                                 MODEST_DBUS_IFACE,

   298                                                 MODEST_DBUS_SIGNAL_FOLDER_UPDATED,

   299                                                 this, SLOT(folderUpdatedSlot(QDBusMessage)));

   300 

   301     // Get notifications of message Read/Unread state changes

   302     m_ModestDBusInterface->connection().connect(MODEST_DBUS_SERVICE,

   303                                                 MODEST_DBUS_OBJECT,

   304                                                 MODEST_DBUS_IFACE,

   305                                                 MODEST_DBUS_SIGNAL_MSG_READ_CHANGED,

   306                                                this, SLOT(messageReadChangedSlot(QDBusMessage)));

   307 

   308     qWarning() << "ModestEngine::ModestEngine Connecting to Qt Mobility Modest Plugin DBus Interface";

   309     // Setup Qt Mobility Modest Plugin based DBus Interface for Modest

   310     m_QtmPluginDBusInterface = new QDBusInterface(MODESTENGINE_QTM_PLUGIN_NAME,

   311                                                   MODESTENGINE_QTM_PLUGIN_PATH,

   312                                                   MODESTENGINE_QTM_PLUGIN_NAME,

   313                                                   QDBusConnection::sessionBus(),

   314                                                   this);

   315 

   316     if (m_QtmPluginDBusInterface->isValid()) {

   317         qWarning() << "ModestEngine::ModestEngine Connected to Qt Mobility Modest Plugin DBus Interface";

   318     } else {

   319         qWarning() << "ModestEngine::ModestEngine Unable to connect to Qt Mobility Modest Plugin DBus Interface";

   320     }

   321 

   322     qDBusRegisterMetaType< ModestStringMap >();

   323     qDBusRegisterMetaType< ModestStringMapList >();

   324 

   325     qRegisterMetaType<INotifyWatcher::FileNotification>();

   326 

   327     qRegisterMetaType<ModestUnreadMessageDBusStruct>();

   328     qRegisterMetaType<ModestAccountsUnreadMessagesDBusStruct>();

   329     qDBusRegisterMetaType<ModestMessage>();

   330 

   331     qRegisterMetaType<MessagingModestMimePart>();

   332 

   333     qRegisterMetaType<MessagingModestFolder>();

   334 

   335 

   336     connect(&m_MailFoldersWatcher, SIGNAL(fileChanged(int, QString, uint)),

   337             this, SLOT(fileChangedSlot(int, QString, uint)));

   338 

   339     watchAllKnownEmailFolders();

   340 

   341     // Get latest messages from each account

   342     // => This ensures that notifications of all incoming messages will be sent

   343     int messagesPerAccount = 1;

   344     QDBusPendingCall pendingCall = m_ModestDBusInterface->asyncCall(MODEST_DBUS_METHOD_GET_UNREAD_MESSAGES,

   345                                                                     messagesPerAccount);

   346     QDBusPendingCallWatcher* pendingCallWatcher = new QDBusPendingCallWatcher(pendingCall);

   347     pendingCallWatcher->setProperty("setOnlyDates", true);

   348     connect(pendingCallWatcher, SIGNAL(finished(QDBusPendingCallWatcher*)),

   349             this, SLOT(pendingGetUnreadMessagesFinishedSlot(QDBusPendingCallWatcher*)));

   350 

   351     QList<MessagingModestFolder> modestFolders;

   352     foldersFromModest(modestFolders);

   353     if (modestFolders.count() > 0) {

   354         for (int i=0; i < modestFolders.count(); i++) {

   355             if (modestFolders[i].type == MessagingModestFolderTypeInbox && modestFolders[i].parentAccountId != "local_folders") {

   356                 QMessageAccountId accountId = accountIdFromModestAccountId(modestFolders[i].parentAccountId);

   357                 if (accountExists(accountId)) {

   358                     QString id = accountId.toString()+"&"+accountEmailProtocolAsString(accountId)+"&"+modestFolders[i].modestId;

   359                     startObservingModestFolder(id);

   360                 }

   361             }

   362         }

   363     }

   364 

   365     qWarning() << "ModestEngine::ModestEngine Initialized successfully";

   366 }

   367 

   368 ModestEngine::~ModestEngine()

   369 {

   370     g_object_unref(m_gconfclient);

   371     m_gconfclient=NULL;

   372 

   373     if (m_observed_folders.count()) {

   374         for (int i = m_observed_folders.count()-1; i >= 0; i--) {

   375             stopObservingModestFolder(m_observed_folders[i]);

   376         }

   377     }

   378 }

   379 

   380 ModestEngine* ModestEngine::instance()

   381 {

   382     return modestEngine();

   383 }

   384 

   385 MessagingModestMessage ModestEngine::messageFromModest(const QString& accountId, const QString &folderId, const QString& messageId) const

   386 {

   387     MessagingModestMessage modestMessage;

   388 

   389     if (!m_QtmPluginDBusInterface->isValid() || iAccounts.isEmpty()) {

   390         return modestMessage;

   391     }

   392 

   393     QDBusPendingCall pendingCall = m_QtmPluginDBusInterface->asyncCall("GetMessage",

   394                                                                        accountId,

   395                                                                        folderId,

   396                                                                        messageId);

   397     QDBusPendingCallWatcher pendingCallWatcher(pendingCall);

   398     pendingCallWatcher.waitForFinished();

   399 

   400     QDBusMessage msg = pendingCallWatcher.reply();

   401 

   402     if (msg.type() == QDBusMessage::ReplyMessage) {

   403         modestMessage.id = messageId;

   404         modestMessage.accountId = accountId;

   405         modestMessage.folderId = folderId;

   406         modestMessage.url = msg.arguments()[0].toString();

   407         modestMessage.mimeType = msg.arguments()[1].toString();

   408         modestMessage.from = msg.arguments()[2].toString();

   409         modestMessage.to = msg.arguments()[3].toString();

   410         modestMessage.cc = msg.arguments()[4].toString();

   411         modestMessage.bcc = msg.arguments()[5].toString();

   412         modestMessage.replyTo = msg.arguments()[6].toString();

   413         modestMessage.subject = msg.arguments()[7].toString();

   414         modestMessage.dateReceived = msg.arguments()[8].toLongLong();

   415         modestMessage.dateSent = msg.arguments()[9].toLongLong();

   416         modestMessage.size = msg.arguments()[10].toLongLong();

   417         modestMessage.flags = static_cast<MessagingModestMessageFlags>(msg.arguments()[11].toUInt());

   418         modestMessage.priority = static_cast<MessagingModestMessagePriority>(msg.arguments()[12].toUInt());

   419 

   420         QVariant variant = msg.arguments()[13];

   421         QDBusArgument argument = variant.value<QDBusArgument>();

   422         argument >> modestMessage.mimeParts;

   423     } else {

   424         modestMessage.dateReceived = 0;

   425         modestMessage.dateSent = 0;

   426         modestMessage.size = 0;

   427         modestMessage.flags = MessagingModestMessageNotDefined;

   428         modestMessage.priority = MessagingModestMessagePriorityNotDefined;

   429     }

   430 

   431     return modestMessage;

   432 }

   433 

   434 void ModestEngine::updateEmailAccounts() const

   435 {

   436     iDefaultEmailAccountId = QMessageAccountId();

   437     iAccounts.clear();

   438 

   439     GSList *accounts;

   440     GError *error = NULL;

   441 

   442     accounts = gconf_client_all_dirs(m_gconfclient, MODESTENGINE_ACCOUNT_NAMESPACE, &error);

   443     if (error) {

   444 #ifdef MESSAGING_DEBUG

   445         qDebug("qtmessaging: failed to list '%s': '%s'", MODESTENGINE_ACCOUNT_NAMESPACE, error->message);

   446 #endif

   447         g_error_free(error);

   448     } else {

   449         gchar *default_account_id = gconf_client_get_string(m_gconfclient, MODESTENGINE_DEFAULT_ACCOUNT, &error);

   450         if (error) {

   451             qWarning("qtmessaging: failed to get '%s': %s", MODESTENGINE_DEFAULT_ACCOUNT, error->message);

   452             g_error_free(error);

   453         }

   454 

   455         const size_t prefix_len = strlen(MODESTENGINE_ACCOUNT_NAMESPACE) + 1;

   456 

   457         GSList *iter = accounts;

   458         while (iter) {

   459             if (!(iter->data)) {

   460                 iter = iter->next;

   461                 continue;

   462             }

   463 

   464             const gchar* account_key = (const gchar*)iter->data;

   465             // account_key = /apps/modest/server_accounts/<account id>

   466             // => take account id from account_key & unescape account id

   467             gchar* unescaped_account_id = gconf_unescape_key(account_key+prefix_len, strlen(account_key)-prefix_len);

   468 

   469             gboolean account_ok = FALSE;

   470             // Check if account is enabled

   471             if (account_key) {

   472                 gchar* key = g_strconcat(account_key, "/", MODESTENGINE_ACCOUNT_ENABLED, NULL);

   473                 account_ok = gconf_client_get_bool(m_gconfclient, key, NULL);

   474                 g_free(key);

   475             }

   476 

   477             // Check if account store is defined

   478             if (account_ok) {

   479                 gchar* key = g_strconcat(account_key, "/", MODESTENGINE_ACCOUNT_STORE_ACCOUNT, NULL);

   480                 gchar* server_account_name = gconf_client_get_string(m_gconfclient, key, NULL);

   481                 if (server_account_name) {

   482                     gchar* escaped_server_account_name = gconf_escape_key(server_account_name, strlen(server_account_name));

   483                     g_free(server_account_name);

   484                     gchar* store_account_key = g_strconcat(MODESTENGINE_SERVER_ACCOUNT_NAMESPACE, "/", escaped_server_account_name, NULL);

   485                     if (!gconf_client_dir_exists(m_gconfclient, store_account_key, NULL)) {

   486                         account_ok = FALSE;

   487                     }

   488                     g_free(store_account_key);

   489                     g_free(escaped_server_account_name);

   490                 }

   491                 g_free(key);

   492             }

   493 

   494             // Check if account transport is defined

   495             if (account_ok) {

   496                 gchar* key = g_strconcat(account_key, "/", MODESTENGINE_ACCOUNT_TRANSPORT_ACCOUNT, NULL);

   497                 gchar* server_account_name = gconf_client_get_string(m_gconfclient, key, NULL);

   498                 if (server_account_name) {

   499                     gchar* escaped_server_account_name = gconf_escape_key(server_account_name, strlen(server_account_name));

   500                     g_free(server_account_name);

   501                     gchar* transport_account_key = g_strconcat(MODESTENGINE_SERVER_ACCOUNT_NAMESPACE, "/", escaped_server_account_name, NULL);

   502                     if (!gconf_client_dir_exists(m_gconfclient, transport_account_key, NULL)) {

   503                         account_ok = FALSE;

   504                     }

   505                     g_free(transport_account_key);

   506                     g_free(escaped_server_account_name);

   507                 }

   508                 g_free(key);

   509             }

   510 

   511             if (account_ok) {

   512                 gchar* escaped_account_id = gconf_escape_key(unescaped_account_id, strlen(unescaped_account_id));

   513                 QString accountId = "MO_"+QString::fromUtf8(escaped_account_id);

   514                 g_free(escaped_account_id);

   515 

   516                 gchar* name_key = g_strconcat(account_key, "/", MODESTENGINE_ACCOUNT_DISPLAY_NAME, NULL);

   517                 gchar* account_name = gconf_client_get_string(m_gconfclient, name_key, NULL);

   518                 QString accountName = QString::fromUtf8(account_name);

   519                 g_free(account_name);

   520                 g_free(name_key);

   521 

   522                 gchar* email_key = g_strconcat(account_key, "/", MODESTENGINE_ACCOUNT_EMAIL, NULL);

   523                 gchar* email = gconf_client_get_string(m_gconfclient, email_key, NULL);

   524                 QString accountAddress = QString::fromUtf8(email);

   525                 g_free(email);

   526                 g_free(email_key);

   527 

   528                 QMessageAccount account = QMessageAccountPrivate::from(QMessageAccountId(accountId),

   529                                                                        accountName,

   530                                                                        QMessageAddress(QMessageAddress::Email, accountAddress),

   531                                                                        QMessage::Email);

   532                 iAccounts.insert(accountId, account);

   533 

   534                 // Check if newly added account is default account

   535                 if (default_account_id) {

   536                     if (!strncmp(default_account_id, unescaped_account_id, strlen(default_account_id))) {

   537                         iDefaultEmailAccountId = accountId;

   538                     }

   539                 }

   540             }

   541 

   542             g_free(unescaped_account_id);

   543             g_free(iter->data);

   544             iter->data = NULL;

   545             iter = g_slist_next(iter);

   546         }

   547         // strings were freed in while loop

   548         // => it's enough to just free accounts list

   549         g_slist_free(accounts);

   550         g_free(default_account_id);

   551     }

   552 }

   553 

   554 QMessageAccountIdList ModestEngine::queryAccounts(const QMessageAccountFilter &filter, const QMessageAccountSortOrder &sortOrder,

   555                                                   uint limit, uint offset, bool &isFiltered, bool &isSorted) const

   556 {

   557     Q_UNUSED(sortOrder)

   558     Q_UNUSED(limit)

   559     Q_UNUSED(offset)

   560 

   561     QMessageAccountIdList accountIds;

   562 

   563     if (!m_QtmPluginDBusInterface->isValid()) {

   564         return accountIds;

   565     }

   566 

   567     updateEmailAccounts();

   568     foreach (QMessageAccount value, iAccounts) {

   569         accountIds.append(value.id());

   570     }

   571 

   572     MessagingHelper::filterAccounts(accountIds, filter);

   573     isFiltered = true;

   574 

   575     isSorted = false;

   576 

   577     return accountIds;

   578 }

   579 

   580 int ModestEngine::countAccounts(const QMessageAccountFilter &filter) const

   581 {

   582     bool isFiltered, isSorted;

   583     return queryAccounts(filter, QMessageAccountSortOrder(), 0, 0, isFiltered, isSorted).count();

   584 }

   585 

   586 QMessageAccount ModestEngine::account(const QMessageAccountId &id) const

   587 {

   588     updateEmailAccounts();

   589     return iAccounts[id.toString()];

   590 }

   591 

   592 QMessageAccountId ModestEngine::defaultAccount() const

   593 {

   594     updateEmailAccounts();

   595     return iDefaultEmailAccountId;

   596 }

   597 

   598 QFileInfoList ModestEngine::localFolders() const

   599 {

   600     QDir dir(localRootFolder());

   601     dir.setFilter(QDir::AllDirs | QDir::NoDotAndDotDot);

   602     QFileInfoList fileInfoList = dir.entryInfoList();

   603     appendLocalSubFolders(fileInfoList, 0);

   604     return fileInfoList;

   605 }

   606 

   607 void ModestEngine::appendLocalSubFolders(QFileInfoList& fileInfoList, int startIndex) const

   608 {

   609     int endIndex = fileInfoList.count();

   610     for (int i=startIndex; i < endIndex; i++) {

   611         QDir dir(fileInfoList[i].absoluteFilePath());

   612         if (dir.exists()) {

   613             dir.setFilter(QDir::AllDirs | QDir::NoDotAndDotDot);

   614             QFileInfoList dirs = dir.entryInfoList();

   615             for (int j = 0; j < dirs.count(); j++) {

   616                 QString fileName = dirs[j].fileName();

   617                 if (fileName != "cur" && fileName != "new" && fileName != "tmp") {

   618                     fileInfoList.append(dirs[j]);

   619                 }

   620             }

   621         }

   622     }

   623     if (fileInfoList.count() > endIndex) {

   624         appendLocalSubFolders(fileInfoList, endIndex);

   625     }

   626 }

   627 

   628 void ModestEngine::appendIMAPSubFolders(QFileInfoList& fileInfoList, int startIndex) const

   629 {

   630     int endIndex = fileInfoList.count();

   631     for (int i=startIndex; i < endIndex; i++) {

   632         QDir dir(fileInfoList[i].absoluteFilePath()+QString("/subfolders"));

   633         if (dir.exists()) {

   634             dir.setFilter(QDir::AllDirs | QDir::NoDotAndDotDot);

   635             fileInfoList.append(dir.entryInfoList());

   636         }

   637     }

   638     if (fileInfoList.count() > endIndex) {

   639         appendIMAPSubFolders(fileInfoList, endIndex);

   640     }

   641 }

   642 

   643 QString ModestEngine::localRootFolder() const

   644 {

   645     return QDir::home().absolutePath()+QString("/.modest/local_folders");

   646 }

   647 

   648 QString ModestEngine::accountRootFolder(QMessageAccountId& accountId) const

   649 {

   650     QString modestAccountId = escapeString(modestAccountIdFromAccountId(accountId));

   651 

   652     QString userName;

   653     QString hostName;

   654     QString port;

   655     QString protocol;

   656 

   657     gchar* store_account_key = g_strconcat(MODESTENGINE_ACCOUNT_NAMESPACE, "/", modestAccountId.toUtf8().data(), "/", MODESTENGINE_ACCOUNT_STORE_ACCOUNT, NULL);

   658     gchar* store_account_name = gconf_client_get_string(m_gconfclient, store_account_key, NULL);

   659     g_free(store_account_key);

   660     gchar* escaped_store_account_name = gconf_escape_key(store_account_name, strlen(store_account_name));

   661     g_free(store_account_name);

   662 

   663     gchar* username_key = g_strconcat(MODESTENGINE_SERVER_ACCOUNT_NAMESPACE, "/", escaped_store_account_name, "/", MODESTENGINE_ACCOUNT_USERNAME, NULL);

   664     gchar* account_username = gconf_client_get_string(m_gconfclient, username_key, NULL);

   665     userName = QString::fromUtf8(account_username);

   666     g_free(account_username);

   667     g_free(username_key);

   668 

   669     gchar* hostname_key = g_strconcat(MODESTENGINE_SERVER_ACCOUNT_NAMESPACE, "/", escaped_store_account_name, "/", MODESTENGINE_ACCOUNT_HOSTNAME, NULL);

   670     gchar* account_hostname = gconf_client_get_string(m_gconfclient, hostname_key, NULL);

   671     hostName = QString::fromUtf8(account_hostname);

   672     g_free(account_hostname);

   673     g_free(hostname_key);

   674 

   675     gchar* port_key = g_strconcat(MODESTENGINE_SERVER_ACCOUNT_NAMESPACE, "/", escaped_store_account_name, "/", MODESTENGINE_ACCOUNT_PORT, NULL);

   676     gint account_port = gconf_client_get_int(m_gconfclient, port_key, NULL);

   677     port = QString::number(account_port);

   678     g_free(port_key);

   679 

   680     gchar* protocol_key = g_strconcat(MODESTENGINE_SERVER_ACCOUNT_NAMESPACE, "/", escaped_store_account_name, "/", MODESTENGINE_ACCOUNT_PROTOCOL, NULL);

   681     gchar* account_protocol = gconf_client_get_string(m_gconfclient, protocol_key, NULL);

   682     protocol = QString::fromUtf8(account_protocol);

   683     g_free(account_protocol);

   684     g_free(protocol_key);

   685 

   686     g_free(escaped_store_account_name);

   687 

   688     if (protocol == "pop") {

   689         return QDir::home().absolutePath()+"/.modest/cache/mail/"+protocol+"/"+userName+"__"+hostName+"_"+port;

   690     } else if (protocol == "imap") {

   691         return QDir::home().absolutePath()+"/.modest/cache/mail/"+protocol+"/"+userName+"__"+hostName+"_"+port+"/folders";

   692     }

   693     return QString();

   694 }

   695 

   696 QFileInfoList ModestEngine::accountFolders(QMessageAccountId& accountId) const

   697 {

   698     QFileInfoList fileInfoList;

   699 

   700     EmailProtocol protocol = accountEmailProtocol(accountId);

   701 

   702     if (protocol == ModestEngine::EmailProtocolPop3) {

   703         QFileInfo fileInfo = QFileInfo(accountRootFolder(accountId)+"/cache");

   704         fileInfoList.append(fileInfo);

   705     } else if (protocol == ModestEngine::EmailProtocolIMAP) {

   706         QDir dir(accountRootFolder(accountId));

   707         dir.setFilter(QDir::AllDirs | QDir::NoDotAndDotDot);

   708         fileInfoList = dir.entryInfoList();

   709         appendIMAPSubFolders(fileInfoList, 0);

   710     }

   711 

   712     return fileInfoList;

   713 }

   714 

   715 ModestEngine::EmailProtocol ModestEngine::accountEmailProtocol(QMessageAccountId& accountId) const

   716 {

   717     EmailProtocol protocol = EmailProtocolUnknown;

   718 

   719     QString modestAccountId = escapeString(modestAccountIdFromAccountId(accountId));

   720 

   721     gchar* store_account_key = g_strconcat(MODESTENGINE_ACCOUNT_NAMESPACE, "/", modestAccountId.toUtf8().data(), "/", MODESTENGINE_ACCOUNT_STORE_ACCOUNT, NULL);

   722     gchar* store_account_name = gconf_client_get_string(m_gconfclient, store_account_key, NULL);

   723     g_free(store_account_key);

   724     gchar* escaped_store_account_name = gconf_escape_key(store_account_name, strlen(store_account_name));

   725     g_free(store_account_name);

   726 

   727     gchar* protocol_key = g_strconcat(MODESTENGINE_SERVER_ACCOUNT_NAMESPACE, "/", escaped_store_account_name, "/", MODESTENGINE_ACCOUNT_PROTOCOL, NULL);

   728     gchar* account_protocol = gconf_client_get_string(m_gconfclient, protocol_key, NULL);

   729     if (QString("pop") == account_protocol) {

   730         protocol = EmailProtocolPop3;

   731     } else if (QString("imap") == account_protocol) {

   732         protocol = EmailProtocolIMAP;

   733     }

   734     g_free(account_protocol);

   735     g_free(protocol_key);

   736 

   737     g_free(escaped_store_account_name);

   738 

   739     return protocol;

   740 }

   741 

   742 bool ModestEngine::accountExists(const QMessageAccountId& accountId) const

   743 {

   744     bool retVal = false;

   745 

   746     QString modestAccountId = escapeString(modestAccountIdFromAccountId(accountId));

   747     gchar* account_key = g_strconcat(MODESTENGINE_ACCOUNT_NAMESPACE, "/", modestAccountId.toUtf8().data(), NULL);

   748     retVal = gconf_client_dir_exists(m_gconfclient, account_key, NULL);

   749     g_free(account_key);

   750 

   751     return retVal;

   752 }

   753 

   754 QString ModestEngine::accountEmailProtocolAsString(const QMessageAccountId& accountId) const

   755 {

   756     QString protocol;

   757 

   758     QString modestAccountId = escapeString(modestAccountIdFromAccountId(accountId));

   759 

   760     gchar* store_account_key = g_strconcat(MODESTENGINE_ACCOUNT_NAMESPACE, "/", modestAccountId.toUtf8().data(), "/", MODESTENGINE_ACCOUNT_STORE_ACCOUNT, NULL);

   761     gchar* store_account_name = gconf_client_get_string(m_gconfclient, store_account_key, NULL);

   762     g_free(store_account_key);

   763     gchar* escaped_store_account_name = gconf_escape_key(store_account_name, strlen(store_account_name));

   764     g_free(store_account_name);

   765 

   766     gchar* protocol_key = g_strconcat(MODESTENGINE_SERVER_ACCOUNT_NAMESPACE, "/", escaped_store_account_name, "/", MODESTENGINE_ACCOUNT_PROTOCOL, NULL);

   767     gchar* account_protocol = gconf_client_get_string(m_gconfclient, protocol_key, NULL);

   768     protocol = QString::fromUtf8(account_protocol);

   769     g_free(account_protocol);

   770     g_free(protocol_key);

   771 

   772     g_free(escaped_store_account_name);

   773 

   774     return protocol;

   775 }

   776 

   777 QString ModestEngine::accountUsername(QMessageAccountId& accountId) const

   778 {

   779     QString username;

   780 

   781     QString modestAccountId = escapeString(modestAccountIdFromAccountId(accountId));

   782 

   783     gchar* store_account_key = g_strconcat(MODESTENGINE_ACCOUNT_NAMESPACE, "/", modestAccountId.toUtf8().data(), "/", MODESTENGINE_ACCOUNT_STORE_ACCOUNT, NULL);

   784     gchar* store_account_name = gconf_client_get_string(m_gconfclient, store_account_key, NULL);

   785     g_free(store_account_key);

   786     gchar* escaped_store_account_name = gconf_escape_key(store_account_name, strlen(store_account_name));

   787     g_free(store_account_name);

   788 

   789     gchar* username_key = g_strconcat(MODESTENGINE_SERVER_ACCOUNT_NAMESPACE, "/", escaped_store_account_name, "/", MODESTENGINE_ACCOUNT_USERNAME, NULL);

   790     gchar* account_username = gconf_client_get_string(m_gconfclient, username_key, NULL);

   791     username = QString::fromUtf8(account_username);

   792     g_free(account_username);

   793     g_free(username_key);

   794 

   795     g_free(escaped_store_account_name);

   796 

   797     return username;

   798 }

   799 

   800 QString ModestEngine::accountHostname(QMessageAccountId& accountId) const

   801 {

   802     QString host;

   803 

   804     QString modestAccountId = escapeString(modestAccountIdFromAccountId(accountId));

   805 

   806     gchar* store_account_key = g_strconcat(MODESTENGINE_ACCOUNT_NAMESPACE, "/", modestAccountId.toUtf8().data(), "/", MODESTENGINE_ACCOUNT_STORE_ACCOUNT, NULL);

   807     gchar* store_account_name = gconf_client_get_string(m_gconfclient, store_account_key, NULL);

   808     g_free(store_account_key);

   809     gchar* escaped_store_account_name = gconf_escape_key(store_account_name, strlen(store_account_name));

   810     g_free(store_account_name);

   811 

   812     gchar* host_key = g_strconcat(MODESTENGINE_SERVER_ACCOUNT_NAMESPACE, "/", escaped_store_account_name, "/", MODESTENGINE_ACCOUNT_HOSTNAME, NULL);

   813     gchar* account_host = gconf_client_get_string(m_gconfclient, host_key, NULL);

   814     host = QString::fromUtf8(account_host);

   815     g_free(account_host);

   816     g_free(host_key);

   817 

   818     g_free(escaped_store_account_name);

   819 

   820     return host;

   821 }

   822 

   823 void ModestEngine::foldersFromModest(QList<MessagingModestFolder>& folders) const

   824 {

   825     if (!m_QtmPluginDBusInterface->isValid() || iAccounts.isEmpty()) {

   826         return;

   827     }

   828 

   829     QDBusPendingCall pendingCall = m_QtmPluginDBusInterface->asyncCall("GetFolders");

   830     QDBusPendingCallWatcher pendingCallWatcher(pendingCall);

   831     pendingCallWatcher.waitForFinished();

   832 

   833     QDBusMessage msg = pendingCallWatcher.reply();

   834 

   835     if (msg.type() == QDBusMessage::ReplyMessage) {

   836         QVariant variant = msg.arguments()[0];

   837         QDBusArgument argument = variant.value<QDBusArgument>();

   838         argument >> folders;

   839     }

   840 }

   841 

   842 QMessageFolderIdList ModestEngine::queryFolders(const QMessageFolderFilter &filter, const QMessageFolderSortOrder &sortOrder,

   843                                                 uint limit, uint offset, bool &isFiltered, bool &isSorted) const

   844 {

   845     Q_UNUSED(sortOrder)

   846     Q_UNUSED(limit)

   847     Q_UNUSED(offset)

   848 

   849     QMessageFolderIdList folderIds;

   850 

   851     if (!m_QtmPluginDBusInterface->isValid()) {

   852         return folderIds;

   853     }

   854 

   855     updateEmailAccounts();

   856 

   857     if (iAccounts.isEmpty()) {

   858         return folderIds;

   859     }

   860 

   861     m_folderCache.clear();

   862 

   863     QList<MessagingModestFolder> modestFolders;

   864     foldersFromModest(modestFolders);

   865 

   866     if (modestFolders.count() > 0) {

   867         foreach (QMessageAccount value, iAccounts) {

   868             QMessageAccountId accountId = value.id();

   869             // Add folder to cache

   870             QString modestAccountId = modestAccountIdFromAccountId(accountId);

   871             for (int j=0; j < modestFolders.count(); j++) {

   872                 if (modestFolders[j].parentAccountId == modestAccountId) {

   873                     MessagingModestFolder folder = modestFolders[j];

   874                     QString id = accountId.toString()+"&"+accountEmailProtocolAsString(accountId)+"&"+folder.modestId;

   875                     folder.id = id;

   876                     m_folderCache.insert(id, folder);

   877 

   878                     folderIds.append(QMessageFolderId(id));

   879                 }

   880             }

   881             for (int j=0; j < modestFolders.count(); j++) {

   882                 if (modestFolders[j].parentAccountId == "local_folders") {

   883                     MessagingModestFolder folder = modestFolders[j];

   884                     QString id = accountId.toString()+"&"+"maildir"+"&"+folder.modestId;

   885                     folder.id = id;

   886                     m_folderCache.insert(id, folder);

   887 

   888                     folderIds.append(QMessageFolderId(id));

   889                 }

   890             }

   891         }

   892     } else {

   893         QFileInfoList localFolders = this->localFolders();

   894         QString localRootFolder = this->localRootFolder();

   895 

   896         foreach (QMessageAccount value, iAccounts) {

   897             QMessageAccountId accountId = value.id();

   898             QString rootFolder = accountRootFolder(accountId);

   899             QFileInfoList folders = this->accountFolders(accountId);

   900 

   901             for (int i=0; i < folders.count(); i++) {

   902                 QString filePath = folders[i].absoluteFilePath();

   903                 QString modestId = filePath.right(filePath.size()-rootFolder.size()-1);

   904                 modestId = modestId.remove("/subfolders");

   905                 QString id = accountId.toString()+"&"+accountEmailProtocolAsString(accountId)+"&"+modestId;

   906                 folderIds.append(QMessageFolderId(id));

   907 

   908                 // Add folder to cache

   909                 MessagingModestFolder folder;

   910                 folder.id = id;

   911                 folder.modestId = modestId;

   912                 if (modestId.lastIndexOf('/') == -1) {

   913                     // Folder does not have subfolders

   914                     folder.name = modestId;

   915                     if ((accountEmailProtocolAsString(accountId) == "pop") && (folder.name == "cache")) {

   916                         folder.name = "Inbox";

   917                     }

   918                 } else {

   919                     // Folder has subfolders

   920                     folder.name = modestId.right(modestId.length()-modestId.lastIndexOf('/')-1);

   921                     folder.parentFolderId = modestId.left(modestId.lastIndexOf('/'));

   922                 }

   923                 folder.parentAccountId = modestAccountIdFromAccountId(accountId);

   924                 folder.type = MessagingModestFolderTypeUnknown;

   925                 m_folderCache.insert(id, folder);

   926             }

   927 

   928             // Each account sees local folders as account folders

   929             for (int i=0; i < localFolders.count(); i++) {

   930                 QString filePath = localFolders[i].absoluteFilePath();

   931                 QString modestId = filePath.right(filePath.size()-localRootFolder.size()-1);

   932                 QString id = accountId.toString()+"&"+"maildir"+"&"+modestId;

   933                 folderIds.append(QMessageFolderId(id));

   934 

   935                 // Add folder to cache

   936                 MessagingModestFolder folder;

   937                 folder.id = id;

   938                 folder.modestId = modestId;

   939                 if (modestId.lastIndexOf('/') == -1) {

   940                     // Folder does not have subfolders

   941                     folder.name = modestId;

   942                     if ((accountEmailProtocolAsString(accountId) == "pop") && (folder.name == "cache")) {

   943                         folder.name = "Inbox";

   944                     }

   945                 } else {

   946                     // Folder has subfolders

   947                     folder.name = modestId.right(modestId.length()-modestId.lastIndexOf('/')-1);

   948                     folder.parentFolderId = modestId.left(modestId.lastIndexOf('/'));

   949                 }

   950                 folder.parentAccountId = "local_folders";

   951                 folder.type = MessagingModestFolderTypeUnknown;

   952                 m_folderCache.insert(id, folder);

   953             }

   954         }

   955     }

   956 

   957     MessagingHelper::filterFolders(folderIds, filter);

   958     isFiltered = true;

   959     isSorted = false;

   960     return folderIds;

   961 }

   962 

   963 int ModestEngine::countFolders(const QMessageFolderFilter &filter) const

   964 {

   965     bool isFiltered, isSorted;

   966     return queryFolders(filter, QMessageFolderSortOrder(), 0, 0, isFiltered, isSorted).count();

   967 }

   968 

   969 QMessageFolder ModestEngine::folder(const QMessageFolderId &id) const

   970 {

   971     QMessageFolder folder;

   972 

   973     QString idString = id.toString();

   974     if (m_folderCache.contains(idString)) {

   975         MessagingModestFolder modestFolder = m_folderCache.value(idString);

   976         int endOfAccountId = idString.indexOf('&');

   977         QString accountId = idString.left(endOfAccountId);

   978         QString folderPath = idString.right(idString.length()-idString.lastIndexOf('&')-1);

   979         QMessageFolderId parentId;

   980         QString name;

   981         if (folderPath.lastIndexOf('/') != -1) {

   982             // Folder has subfolders

   983             parentId = idString.left(idString.lastIndexOf('/'));

   984         }

   985 

   986         if (modestFolder.localizedName.isEmpty()) {

   987             folder = QMessageFolderPrivate::from(id,

   988                                                  QMessageAccountId(accountId),

   989                                                  parentId,

   990                                                  modestFolder.name,

   991                                                  folderPath);

   992         } else {

   993             folder = QMessageFolderPrivate::from(id,

   994                                                  QMessageAccountId(accountId),

   995                                                  parentId,

   996                                                  modestFolder.localizedName,

   997                                                  folderPath);

   998         }

   999     }

  1000 

  1001     return folder;

  1002 }

  1003 

  1004 bool ModestEngine::startObservingModestFolder(const QMessageFolderId& folderId) const

  1005 {

  1006     if (!m_QtmPluginDBusInterface->isValid() || iAccounts.isEmpty()) {

  1007         return false;

  1008     }

  1009 

  1010     if (!m_observed_folders.contains(folderId)) {

  1011         QDBusPendingCall pendingCall = m_QtmPluginDBusInterface->asyncCall("AddFolderObserver",

  1012                                                                            QVariant::fromValue(modestAccountIdFromFolderId(folderId)),

  1013                                                                            QVariant::fromValue(modestFolderIdFromFolderId(folderId)));

  1014         QDBusPendingCallWatcher pendingCallWatcher(pendingCall);

  1015         pendingCallWatcher.waitForFinished();

  1016 

  1017         QDBusMessage msg = pendingCallWatcher.reply();

  1018 

  1019         if (msg.type() == QDBusMessage::ReplyMessage) {

  1020             if (m_observed_folders.count() == 0) {

  1021                 m_QtmPluginDBusInterface->connection().connect(MODESTENGINE_QTM_PLUGIN_NAME,

  1022                                                                MODESTENGINE_QTM_PLUGIN_PATH,

  1023                                                                MODESTENGINE_QTM_PLUGIN_NAME,

  1024                                                                "FolderContentsChanged",

  1025                                                                (ModestEngine*)this,

  1026                                                                SLOT(modestFolderContentsChangedSlot(QDBusMessage)));

  1027             }

  1028 

  1029             m_observed_folders.append(folderId);

  1030 

  1031             return true;

  1032         }

  1033     } else {

  1034         return true;

  1035     }

  1036 

  1037     return false;

  1038 }

  1039 

  1040 bool ModestEngine::stopObservingModestFolder(const QMessageFolderId& folderId) const

  1041 {

  1042     if (!m_QtmPluginDBusInterface->isValid() || iAccounts.isEmpty()) {

  1043         return false;

  1044     }

  1045 

  1046     if (m_observed_folders.contains(folderId)) {

  1047         QDBusPendingCall pendingCall = m_QtmPluginDBusInterface->asyncCall("RemoveFolderObserver",

  1048                                                                            QVariant::fromValue(modestAccountIdFromFolderId(folderId)),

  1049                                                                            QVariant::fromValue(modestFolderIdFromFolderId(folderId)));

  1050         QDBusPendingCallWatcher pendingCallWatcher(pendingCall);

  1051         pendingCallWatcher.waitForFinished();

  1052 

  1053         QDBusMessage msg = pendingCallWatcher.reply();

  1054 

  1055         if (msg.type() == QDBusMessage::ReplyMessage) {

  1056             m_observed_folders.removeOne(folderId);

  1057 

  1058             if (m_observed_folders.count() == 0) {

  1059                 m_QtmPluginDBusInterface->connection().disconnect(MODESTENGINE_QTM_PLUGIN_NAME,

  1060                                                                   MODESTENGINE_QTM_PLUGIN_PATH,

  1061                                                                   MODESTENGINE_QTM_PLUGIN_NAME,

  1062                                                                   "FolderContentsChanged",

  1063                                                                   (ModestEngine*)this,

  1064                                                                   SLOT(modestFolderContentsChangedSlot(QDBusMessage)));

  1065             }

  1066 

  1067             return true;

  1068         }

  1069     }

  1070 

  1071     return false;

  1072 }

  1073 

  1074 void ModestEngine::modestFolderContentsChangedSlot(QDBusMessage msg)

  1075 {

  1076     QList<QVariant> arguments = msg.arguments();

  1077 

  1078     QString modestAccountId = arguments.takeFirst().toString();

  1079     QString modestFolderId = arguments.takeFirst().toString();

  1080     QMessageAccountId accountId = accountIdFromModestAccountId(modestAccountId);

  1081     QString protocol = accountEmailProtocolAsString(accountId);

  1082     if ((protocol == "pop") && (modestFolderId == "INBOX")) {

  1083         modestFolderId = "cache";

  1084     }

  1085     QString folderId = accountId.toString()+"&"+accountEmailProtocolAsString(accountId)+"&"+modestFolderId;

  1086 

  1087     qlonglong change = arguments.takeFirst().toLongLong();

  1088     QVariant variant = arguments.takeFirst();

  1089     QList<QString> messageIds = variant.toStringList();

  1090     if (change == 4) { // Headers added

  1091         for (int i = 0; i < messageIds.count(); i++) {

  1092             QMessageId messageId = folderId+"/"+messageIds[i];

  1093             notification(messageId, ModestEngine::Added);

  1094         }

  1095     }/* else if (change == 8) { // Headers removed

  1096         for (int i = 0; i < messageIds.count(); i++) {

  1097             QMessageId messageId = folderId+"/"+messageIds[i];

  1098             notification(messageId, ModestEngine::Removed);

  1099         }

  1100     }*/

  1101 }

  1102 

  1103 void ModestEngine::watchAllKnownEmailFolders()

  1104 {

  1105     QFileInfoList localFolders = this->localFolders();

  1106 

  1107     // Changes in local Email folders can be monitored using directory

  1108     // monitoring. <=> All messages are stored as individual files.

  1109     for (int i=0; i < localFolders.count(); i++) {

  1110         m_MailFoldersWatcher.addDirectory(localFolders[i].absoluteFilePath()+"/cur", IN_MOVED_TO | IN_DELETE);

  1111     }

  1112 

  1113     // Monitor changes also in root folder to see if new folders are added

  1114     m_MailFoldersWatcher.addDirectory(localRootFolder(), IN_CREATE);

  1115 

  1116     // Changes in remote Email folders must be monitored using file monitoring.

  1117     // That's because message headers are stored into summary.mmap file (and summary.mmap

  1118     // file maybe the only place that contains message information).

  1119     // => summary.mmap files will be monitored

  1120     foreach (QMessageAccount value, iAccounts) {

  1121         QMessageAccountId accountId = value.id();

  1122         QString rootFolder = accountRootFolder(accountId);

  1123         EmailProtocol protocol = accountEmailProtocol(accountId);

  1124         QFileInfoList folders = this->accountFolders(accountId);

  1125 

  1126         for (int i=0; i < folders.count(); i++) {

  1127             if (protocol == ModestEngine::EmailProtocolPop3) {

  1128                 QString folder = folders[i].absoluteFilePath();

  1129                 m_MailFoldersWatcher.addDirectory(folder, IN_CREATE);

  1130             } else if (protocol == ModestEngine::EmailProtocolIMAP) {

  1131                 m_MailFoldersWatcher.addDirectory(folders[i].absoluteFilePath(), IN_MOVED_TO | IN_DELETE);

  1132             }

  1133         }

  1134 

  1135     }