--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/messaging/qfsengine_symbian.cpp Wed Aug 25 15:49:42 2010 +0300
@@ -0,0 +1,2851 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the Qt Mobility Components.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qmessageservice.h"
+#include "qmessageservice_symbian_p.h"
+#include "qfsengine_symbian_p.h"
+#include "qmessage_symbian_p.h"
+#include "messagingutil_p.h"
+#include "qmessageaccount.h"
+#include "qmessageaccount_p.h"
+#include "qmessageaccountfilter.h"
+#include "qmessageaccountfilter_p.h"
+#include "qmessagecontentcontainer_symbian_p.h"
+#include "qmessagefolder.h"
+#include "qmessagefolder_p.h"
+#include "qmessagefolderfilter.h"
+#include "qmessagefolderfilter_p.h"
+#include "qmessageaccountsortorder_p.h"
+#include "qmessagestore_symbian_p.h"
+#include "qmessagefoldersortorder_p.h"
+#include "qmessagesortorder_p.h"
+
+#include <emailinterfacefactory.h>
+#include <QTextCodec>
+#include <emailapidefs.h>
+#include <memailmailbox.h>
+#include <memailfolder.h>
+#include <memailmessage.h>
+#include <memailaddress.h>
+#include <memailcontent.h>
+#include <mmessageiterator.h>
+
+using namespace EmailInterface;
+
+QTM_BEGIN_NAMESPACE
+
+using namespace SymbianHelpers;
+
+Q_GLOBAL_STATIC(CFSEngine,fsEngine);
+
+CFSEngine::CFSEngine()
+{
+ connect(QCoreApplication::instance(), SIGNAL(aboutToQuit()), this, SLOT(cleanupFSBackend()));
+
+ TRAPD(err, {
+ m_factory = CEmailInterfaceFactory::NewL();
+ m_ifPtr = m_factory->InterfaceL(KEmailClientApiInterface);
+ });
+
+ Q_UNUSED(err);
+ m_clientApi = static_cast<MEmailClientApi*>(m_ifPtr);
+#ifdef FREESTYLEMAILBOXOBSERVERUSED
+ TRAPD(err2, setPluginObserversL());
+ Q_UNUSED(err2);
+#endif
+}
+
+CFSEngine::~CFSEngine()
+{
+
+}
+
+void CFSEngine::cleanupFSBackend()
+{
+ m_mtmAccountList.clear();
+ for (TInt i = 0; i < m_attachments.Count(); i++){
+ m_attachments[i]->Release();
+ }
+ m_attachments.Reset();
+ for (TInt i = 0; i < m_mailboxes.Count(); i++){
+ m_mailboxes[i]->Release();
+ }
+ m_mailboxes.Reset();
+ m_clientApi->Release();
+ delete m_factory;
+}
+
+CFSEngine* CFSEngine::instance()
+{
+ return fsEngine();
+}
+
+bool CFSEngine::accountLessThan(const QMessageAccountId accountId1, const QMessageAccountId accountId2)
+{
+ CFSEngine* freestyleEngine = fsEngine();
+ return QMessageAccountSortOrderPrivate::lessThan(freestyleEngine->m_currentAccountOrdering,
+ freestyleEngine->account(accountId1),
+ freestyleEngine->account(accountId2));
+}
+
+void CFSEngine::orderAccounts(QMessageAccountIdList& accountIds, const QMessageAccountSortOrder &sortOrder) const
+{
+ Q_UNUSED(accountIds);
+ m_currentAccountOrdering = sortOrder;
+ qSort(accountIds.begin(), accountIds.end(), CFSEngine::accountLessThan);
+}
+
+bool CFSEngine::folderLessThan(const QMessageFolderId folderId1, const QMessageFolderId folderId2)
+{
+ CFSEngine* freestyleEngine = fsEngine();
+ return QMessageFolderSortOrderPrivate::lessThan(freestyleEngine->m_currentFolderOrdering,
+ freestyleEngine->folder(folderId1),
+ freestyleEngine->folder(folderId2));
+}
+
+void CFSEngine::orderFolders(QMessageFolderIdList& folderIds, const QMessageFolderSortOrder &sortOrder) const
+{
+ m_currentFolderOrdering = sortOrder;
+ qSort(folderIds.begin(), folderIds.end(), CFSEngine::folderLessThan);
+}
+
+bool CFSEngine::messageLessThan(const QMessage& message1, const QMessage& message2)
+{
+ CFSEngine* freestyleEngine = fsEngine();
+ return QMessageSortOrderPrivate::lessThan(freestyleEngine->m_currentMessageOrdering, message1, message2);
+}
+
+void CFSEngine::orderMessages(QMessageIdList& messageIds, const QMessageSortOrder &sortOrder) const
+{
+ m_currentMessageOrdering = sortOrder;
+ QList<QMessage> messages;
+ for (int i=0; i < messageIds.count(); i++) {
+ messages.append(message(messageIds[i]));
+ }
+ qSort(messages.begin(), messages.end(), CFSEngine::messageLessThan);
+ messageIds.clear();
+ for (int i=0; i < messages.count(); i++) {
+ messageIds.append(messages[i].id());
+ }
+}
+
+void CFSEngine::setMtmAccountIdList(QMessageAccountIdList accountList)
+{
+ for (TInt i = 0; i < accountList.count(); i++) {
+ m_mtmAccountList.append(stripIdPrefix(accountList[i]));
+ }
+}
+
+QMessageAccountIdList CFSEngine::queryAccounts(const QMessageAccountFilter &filter, const QMessageAccountSortOrder &sortOrder, uint limit, uint offset) const
+{
+ QMessageAccountIdList accountIds;
+
+ TRAPD(err, updateEmailAccountsL());
+ Q_UNUSED(err);
+
+ QMessageAccountFilterPrivate* privateMessageAccountFilter = QMessageAccountFilterPrivate::implementation(filter);
+ if (filter.isEmpty()) {
+ if (!privateMessageAccountFilter->_notFilter) {
+ // All accounts are returned for empty filter
+ foreach (QMessageAccount value, m_accounts) {
+ accountIds.append(value.id());
+ }
+ }
+ } else {
+ if (privateMessageAccountFilter->_valid) {
+ foreach (QMessageAccount value, m_accounts) {
+ if (privateMessageAccountFilter->filter(value)) {
+ accountIds.append(value.id());
+ }
+ }
+ } else {
+ foreach (QMessageAccount value, m_accounts) {
+ if (privateMessageAccountFilter->filter(value)) {
+ accountIds.append(value.id());
+ }
+ }
+ }
+ }
+
+ if (!sortOrder.isEmpty()) {
+ orderAccounts(accountIds, sortOrder);
+ }
+
+ applyOffsetAndLimitToAccountIds(accountIds, offset, limit);
+
+ return accountIds;
+}
+
+void CFSEngine::applyOffsetAndLimitToAccountIds(QMessageAccountIdList& idList, int offset, int limit) const
+{
+ if (offset > 0) {
+ if (offset > idList.count()) {
+ idList.clear();
+ } else {
+ for (int i = 0; i < offset; i++) {
+ idList.removeFirst();
+ }
+ }
+ }
+ if (limit > 0) {
+ for (int i = idList.count()-1; i >= limit; i--) {
+ idList.removeAt(i);
+ }
+ }
+}
+
+int CFSEngine::countAccounts(const QMessageAccountFilter &filter) const
+{
+ return queryAccounts(filter, QMessageAccountSortOrder(), 0, 0).count();
+}
+
+QMessageAccount CFSEngine::account(const QMessageAccountId &id) const
+{
+ TRAPD(err, updateEmailAccountsL());
+ Q_UNUSED(err)
+ return m_accounts[id.toString()];
+}
+
+QMessageAccountId CFSEngine::defaultAccount(QMessage::Type type) const
+{
+ // TODO
+ Q_UNUSED(type);
+ return QMessageAccountId();
+}
+
+QMessageAccountIdList CFSEngine::accountsByType(QMessage::Type type) const
+{
+ QMessageAccountIdList accountIds = QMessageAccountIdList();
+
+ foreach (QMessageAccount value, m_accounts) {
+ if ((value.messageTypes() & type) == (int)type) {
+ accountIds.append(value.id());
+ }
+ }
+
+ return accountIds;
+}
+
+
+void CFSEngine::updateEmailAccountsL() const
+{
+ QStringList keys = m_accounts.keys();
+ RMailboxPtrArray mailboxes;
+ CleanupResetAndRelease<MEmailMailbox>::PushL(mailboxes);
+
+ m_clientApi->GetMailboxesL(mailboxes);
+
+ for (TInt i = 0; i < mailboxes.Count(); i++) {
+ MEmailMailbox *mailbox = mailboxes[i];
+ QString idAsString = QString::number(mailbox->MailboxId().iId);
+ QString fsIdAsString = addIdPrefix(idAsString, SymbianHelpers::EngineTypeFreestyle);
+ TBool overlap = false;
+ for (TInt j = 0; j < m_mtmAccountList.count(); j++) {
+ if (idAsString == m_mtmAccountList[j].toString())
+ overlap = true;
+ }
+ if (!m_accounts.contains(fsIdAsString) && !overlap) {
+ QMessageAccount account = QMessageAccountPrivate::from(
+ QMessageAccountId(fsIdAsString),
+ QString::fromUtf16(mailbox->MailboxName().Ptr(), mailbox->MailboxName().Length()),
+ 0,
+ 0,
+ QMessage::Email);
+
+ m_accounts.insert(fsIdAsString, account);
+
+ } else {
+ keys.removeOne(fsIdAsString);
+ }
+ mailbox->Release();
+ }
+
+ mailboxes.Reset();
+ CleanupStack::PopAndDestroy();
+
+ for (int i=0; i < keys.count(); i++) {
+ m_accounts.remove(keys[i]);
+ }
+}
+
+#ifdef FREESTYLEMAILBOXOBSERVERUSED
+void CFSEngine::setPluginObserversL()
+{
+ m_clientApi->GetMailboxesL(m_mailboxes);
+ for (TInt i = 0; i < m_mailboxes.Count(); i++) {
+ MEmailMailbox *mailbox = m_mailboxes[i];
+ mailbox->RegisterObserverL(*this);
+ }
+}
+
+void CFSEngine::NewMessageEventL(const TMailboxId& aMailbox, const REmailMessageIdArray aNewMessages, const TFolderId& aParentFolderId)
+{
+ QMessageManager::NotificationFilterIdSet matchingFilters;
+ QMessageStorePrivate::NotificationType notificationType = QMessageStorePrivate::Added;
+
+ for (TInt i = 0; i < aNewMessages.Count(); i++) {
+ TMessageId messageId(aNewMessages[i]);
+ notificationL(aMailbox, messageId, aParentFolderId, notificationType);
+ }
+}
+
+void CFSEngine::MessageChangedEventL(const TMailboxId& aMailbox, const REmailMessageIdArray aChangedMessages, const TFolderId& aParentFolderId)
+{
+ QMessageManager::NotificationFilterIdSet matchingFilters;
+ QMessageStorePrivate::NotificationType notificationType = QMessageStorePrivate::Updated;
+
+ for (TInt i = 0; i < aChangedMessages.Count(); i++) {
+ TMessageId messageId(aChangedMessages[i]);
+ notificationL(aMailbox, messageId, aParentFolderId, notificationType);
+ }
+}
+
+void CFSEngine::MessageDeletedEventL(const TMailboxId& aMailbox, const REmailMessageIdArray aDeletedMessages, const TFolderId& aParentFolderId)
+{
+ // TODO: add filter handling
+ QMessageManager::NotificationFilterIdSet matchingFilters;
+ QMap<int, QMessageFilter> filters(m_filters);
+ QMap<int, QMessageFilter>::const_iterator it = filters.begin(), end = filters.end();
+ QMessageStorePrivate::NotificationType notificationType = QMessageStorePrivate::Removed;
+ MEmailMailbox* mailbox = m_clientApi->MailboxL(aMailbox);
+ MEmailFolder* folder = mailbox->FolderL(aParentFolderId);
+ QString idAsString = QString::number(mailbox->MailboxId().iId);
+ for (TInt j = 0; j < m_mtmAccountList.count(); j++) {
+ if (idAsString == m_mtmAccountList[j].toString())
+ return;
+ }
+ for (TInt i = 0; i < aDeletedMessages.Count(); i++) {
+ for ( ; it != end; ++it) {
+ // Empty filter matches to all messages
+ matchingFilters.insert(it.key());
+ }
+ TMessageId messageId(aDeletedMessages[i]);
+ ipMessageStorePrivate->messageNotification(notificationType,
+ QMessageId(addIdPrefix(QString::number(messageId.iId), SymbianHelpers::EngineTypeFreestyle)),
+ matchingFilters);
+ }
+ folder->Release();
+ mailbox->Release();
+}
+
+void CFSEngine::notificationL(const TMailboxId& aMailbox, const TMessageId& aMessageId,
+ const TFolderId& aParentFolderId, QMessageStorePrivate::NotificationType aNotificationType)
+{
+ Q_UNUSED(aParentFolderId);
+ QMessageManager::NotificationFilterIdSet matchingFilters;
+ // Copy the filter map to protect against modification during traversal
+ QMap<int, QMessageFilter> filters(m_filters);
+ QMap<int, QMessageFilter>::const_iterator it = filters.begin(), end = filters.end();
+ QMessage message;
+ QMessageId realMessageId = QMessageId(addIdPrefix(QString::number(aMessageId.iId), SymbianHelpers::EngineTypeFreestyle));
+ bool messageRetrieved = false;
+ MEmailMailbox* mailbox = m_clientApi->MailboxL(aMailbox);
+ CleanupReleasePushL(*mailbox);
+ QString idAsString = QString::number(mailbox->MailboxId().iId);
+ for (TInt j = 0; j < m_mtmAccountList.count(); j++) {
+ if (idAsString == m_mtmAccountList[j].toString()) {
+ CleanupStack::Pop(mailbox);
+ return;
+ }
+ }
+ for ( ; it != end; ++it) {
+ const QMessageFilter &filter(it.value());
+ if (!messageRetrieved) {
+ MEmailMessage* fsMessage = mailbox->MessageL(aMessageId);
+ CleanupReleasePushL(*fsMessage);
+
+ if (!fsMessage) {
+ CleanupStack::Pop(fsMessage);
+ CleanupStack::Pop(mailbox);
+ return;
+ }
+ message = CreateQMessageL(fsMessage);
+ messageRetrieved = true;
+ CleanupStack::Pop(fsMessage);
+ }
+
+ if (filter.isEmpty()) {
+ // Empty filter matches to all messages
+ matchingFilters.insert(it.key());
+ } else {
+ if (message.type() == QMessage::NoType) {
+ matchingFilters.clear();
+ continue;
+ }
+ }
+ QMessageFilterPrivate* privateMessageFilter = QMessageFilterPrivate::implementation(filter);
+ if (privateMessageFilter->filter(message)) {
+ matchingFilters.insert(it.key());
+ }
+
+ }
+ int c = matchingFilters.count();
+ QString id = realMessageId.toString();
+ if (matchingFilters.count() > 0)
+ ipMessageStorePrivate->messageNotification(aNotificationType, realMessageId, matchingFilters);
+
+ CleanupStack::Pop(mailbox);
+}
+
+#endif
+
+MEmailMessage* CFSEngine::createFSMessageL(const QMessage &message, const MEmailMailbox* mailbox)
+{
+ MEmailMessage* fsMessage = mailbox->CreateDraftMessageL();
+ CleanupReleasePushL(*fsMessage);
+
+ switch (message.priority()) {
+ case QMessage::HighPriority:
+ fsMessage->SetFlag(EmailInterface::EFlag_Important);
+ fsMessage->ResetFlag(EmailInterface::EFlag_Low);
+ break;
+ case QMessage::NormalPriority:
+ fsMessage->ResetFlag(EmailInterface::EFlag_Important);
+ fsMessage->ResetFlag(EmailInterface::EFlag_Low);
+ break;
+ case QMessage::LowPriority:
+ fsMessage->SetFlag(EmailInterface::EFlag_Low);
+ fsMessage->ResetFlag(EmailInterface::EFlag_Important);
+ break;
+ }
+ if (message.status() & QMessage::Read) {
+ fsMessage->SetFlag(EmailInterface::EFlag_Read);
+ } else {
+ fsMessage->ResetFlag(EmailInterface::EFlag_Read);
+ }
+
+ MEmailAddress* sender = mailbox->AddressL();
+ sender->SetRole(MEmailAddress::ESender);
+ fsMessage->SetReplyToAddressL(*sender);
+
+ QList<QMessageAddress> toList(message.to());
+ if (toList.count() > 0) {
+ TPtrC16 receiver(KNullDesC);
+ QString qreceiver;
+ REmailAddressArray toAddress;
+ for (int i = 0; i < toList.size(); ++i) {
+ qreceiver = toList.at(i).addressee();
+ receiver.Set(reinterpret_cast<const TUint16*>(qreceiver.utf16()));
+ MEmailAddress* address = mailbox->AddressL();
+ address->SetAddressL(receiver);
+ address->SetDisplayNameL(receiver);
+ address->SetRole(MEmailAddress::ETo);
+ toAddress.Append(address);
+ }
+ fsMessage->SetRecipientsL(MEmailAddress::ETo, toAddress);
+ }
+
+ QList<QMessageAddress> ccList(message.cc());
+ if (ccList.count() > 0) {
+ TPtrC16 receiver(KNullDesC);
+ QString qreceiver;
+ REmailAddressArray ccAddress;
+ for (int i = 0; i < ccList.size(); ++i) {
+ qreceiver = ccList.at(i).addressee();
+ receiver.Set(reinterpret_cast<const TUint16*>(qreceiver.utf16()));
+ MEmailAddress* address = mailbox->AddressL();
+ address->SetDisplayNameL(receiver);
+ address->SetRole(MEmailAddress::ECc);
+ address->SetAddressL(receiver);
+ ccAddress.Append(address);
+ }
+ fsMessage->SetRecipientsL(MEmailAddress::ECc, ccAddress);
+ }
+
+ QList<QMessageAddress> bccList(message.bcc());
+ if (bccList.count() > 0) {
+ TPtrC16 receiver(KNullDesC);
+ QString qreceiver;
+ REmailAddressArray bccAddress;
+ for (int i = 0; i < bccList.size(); ++i) {
+ qreceiver = bccList.at(i).addressee();
+ receiver.Set(reinterpret_cast<const TUint16*>(qreceiver.utf16()));
+ MEmailAddress* address = mailbox->AddressL();
+ address->SetDisplayNameL(receiver);
+ address->SetRole(MEmailAddress::EBcc);
+ address->SetAddressL(receiver);
+ bccAddress.Append(address);
+ }
+ fsMessage->SetRecipientsL(MEmailAddress::EBcc, bccAddress);
+ }
+ if (message.bodyId() == QMessageContentContainerPrivate::bodyContentId()) {
+ // Message contains only body (not attachments)
+ QString messageBody = message.textContent();
+ if (!messageBody.isEmpty()) {
+ QByteArray type = message.contentType();
+ QByteArray subType = message.contentSubType();
+ MEmailMessageContent* content = fsMessage->ContentL();
+ MEmailTextContent* textContent = content->AsTextContentOrNull();
+ if (textContent) {
+ if (type == "text" && subType == "plain") {
+ textContent->SetTextL(MEmailTextContent::EPlainText, TPtrC(reinterpret_cast<const TUint16*>(message.textContent().utf16())));
+ }
+ else if (type == "text" && subType == "html") {
+ textContent->SetTextL(MEmailTextContent::EHtmlText, TPtrC(reinterpret_cast<const TUint16*>(message.textContent().utf16())));
+ }
+ }
+ else
+ fsMessage->SetPlainTextBodyL(TPtrC(reinterpret_cast<const TUint16*>(message.textContent().utf16())));
+ }
+ } else {
+ // Message contains body and attachments
+ QMessageContentContainerIdList contentIds = message.contentIds();
+ foreach (QMessageContentContainerId id, contentIds){
+ QMessageContentContainer container = message.find(id);
+ MEmailMessageContent* content = fsMessage->ContentL();
+ QMessageContentContainerPrivate* pPrivateContainer = QMessageContentContainerPrivate::implementation(container);
+ if (pPrivateContainer->_id == message.bodyId()) {
+ // ContentContainer is body
+ if (!container.textContent().isEmpty()) {
+ MEmailTextContent* textContent = content->AsTextContentOrNull();
+ if (textContent) {
+ QByteArray type = container.contentType();
+ QByteArray subType = container.contentSubType();
+ if (type == "text" && subType == "plain") {
+ textContent->SetTextL(MEmailTextContent::EPlainText, TPtrC(reinterpret_cast<const TUint16*>(container.textContent().utf16())));
+ }
+ else if (type == "text" && subType == "html") {
+ textContent->SetTextL(MEmailTextContent::EHtmlText, TPtrC(reinterpret_cast<const TUint16*>(container.textContent().utf16())));
+ }
+ }
+ else
+ fsMessage->SetPlainTextBodyL(TPtrC(reinterpret_cast<const TUint16*>(container.textContent().utf16())));
+ }
+ } else {
+ // ContentContainer is attachment
+ QByteArray filePath = QMessageContentContainerPrivate::attachmentFilename(container);
+ // Replace Qt style path separator "/" with Symbian path separator "\"
+ filePath.replace(QByteArray("/"), QByteArray("\\"));
+ QString temp_path = QString(filePath);
+ TPtrC16 attachmentPath(KNullDesC);
+ attachmentPath.Set(reinterpret_cast<const TUint16*>(temp_path.utf16()));
+ fsMessage->AddAttachmentL(attachmentPath);
+ }
+ }
+ }
+ fsMessage->SetSubjectL(TPtrC(reinterpret_cast<const TUint16*>(message.subject().utf16())));
+
+ QMessagePrivate* privateMessage = QMessagePrivate::implementation(message);
+ privateMessage->_id = QMessageId(addIdPrefix(QString::number(fsMessage->MessageId().iId),SymbianHelpers::EngineTypeFreestyle));
+
+ fsMessage->SaveChangesL();
+ CleanupStack::Pop(fsMessage);
+ return fsMessage;
+}
+
+bool CFSEngine::addMessage(QMessage* message)
+{
+ TMailboxId mailboxId(stripIdPrefix(message->parentAccountId().toString()).toInt());
+ MEmailMailbox* mailbox = NULL;
+ TRAPD(mailerr, mailbox = m_clientApi->MailboxL(mailboxId));
+ if (mailerr != KErrNone)
+ return false;
+
+ MEmailMessage* fsMessage = NULL;
+ TRAPD(err, fsMessage = createFSMessageL(*message, mailbox));
+ if (fsMessage)
+ fsMessage->Release();
+ if (mailbox)
+ mailbox->Release();
+
+ if (err != KErrNone)
+ return false;
+ else
+ return true;
+}
+
+bool CFSEngine::updateMessage(QMessage* message)
+{
+ TRAPD(err, updateMessageL(message));
+ if (err != KErrNone)
+ return false;
+ else
+ return true;
+}
+
+void CFSEngine::updateMessageL(QMessage* message)
+{
+ TMailboxId mailboxId(stripIdPrefix(message->parentAccountId().toString()).toInt());
+ MEmailMailbox* mailbox = m_clientApi->MailboxL(mailboxId);
+ CleanupReleasePushL(*mailbox);
+
+ TMessageId messageId(message->id().toString().toInt(),
+ message->parentFolderId().toString().toInt(),
+ mailboxId);
+ MEmailMessage* fsMessage = mailbox->MessageL(messageId);
+ CleanupReleasePushL(*fsMessage);
+
+ switch (message->priority()) {
+ case QMessage::HighPriority:
+ fsMessage->SetFlag(EmailInterface::EFlag_Important);
+ fsMessage->ResetFlag(EmailInterface::EFlag_Low);
+ break;
+ case QMessage::NormalPriority:
+ fsMessage->ResetFlag(EmailInterface::EFlag_Important);
+ fsMessage->ResetFlag(EmailInterface::EFlag_Low);
+ break;
+ case QMessage::LowPriority:
+ fsMessage->SetFlag(EmailInterface::EFlag_Low);
+ fsMessage->ResetFlag(EmailInterface::EFlag_Important);
+ break;
+ }
+ if (message->status() & QMessage::Read) {
+ fsMessage->SetFlag(EmailInterface::EFlag_Read);
+ } else {
+ fsMessage->ResetFlag(EmailInterface::EFlag_Read);
+ }
+
+ MEmailAddress* sender = mailbox->AddressL();
+ sender->SetRole(MEmailAddress::ESender);
+ fsMessage->SetReplyToAddressL(*sender);
+
+ QList<QMessageAddress> toList(message->to());
+ if (toList.count() > 0) {
+ TPtrC16 receiver(KNullDesC);
+ QString qreceiver;
+ REmailAddressArray toAddress;
+ for (int i = 0; i < toList.size(); ++i) {
+ qreceiver = toList.at(i).addressee();
+ receiver.Set(reinterpret_cast<const TUint16*>(qreceiver.utf16()));
+ MEmailAddress* address = mailbox->AddressL();
+ address->SetAddressL(receiver);
+ toAddress.Append(address);
+ }
+ fsMessage->SetRecipientsL(MEmailAddress::ETo, toAddress);
+ }
+
+ QList<QMessageAddress> ccList(message->cc());
+ if (ccList.count() > 0) {
+ TPtrC16 receiver(KNullDesC);
+ QString qreceiver;
+ REmailAddressArray ccAddress;
+ for (int i = 0; i < ccList.size(); ++i) {
+ qreceiver = ccList.at(i).addressee();
+ receiver.Set(reinterpret_cast<const TUint16*>(qreceiver.utf16()));
+ MEmailAddress* address = mailbox->AddressL();;
+ address->SetAddressL(receiver);
+ ccAddress.Append(address);
+ }
+ fsMessage->SetRecipientsL(MEmailAddress::ECc, ccAddress);
+ }
+
+ QList<QMessageAddress> bccList(message->bcc());
+ if (bccList.count() > 0) {
+ TPtrC16 receiver(KNullDesC);
+ QString qreceiver;
+ REmailAddressArray bccAddress;
+ for (int i = 0; i < bccList.size(); ++i) {
+ qreceiver = bccList.at(i).addressee();
+ receiver.Set(reinterpret_cast<const TUint16*>(qreceiver.utf16()));
+ MEmailAddress* address = mailbox->AddressL();;
+ address->SetAddressL(receiver);
+ bccAddress.Append(address);
+ }
+ fsMessage->SetRecipientsL(MEmailAddress::EBcc, bccAddress);
+ }
+
+ if (message->bodyId() == QMessageContentContainerPrivate::bodyContentId()) {
+ // Message contains only body (not attachments)
+ QString messageBody = message->textContent();
+ if (!messageBody.isEmpty()) {
+ MEmailMessageContent* content = fsMessage->ContentL();
+ MEmailTextContent* textContent = content->AsTextContentOrNull();
+ textContent->SetTextL(MEmailTextContent::EPlainText, TPtrC(reinterpret_cast<const TUint16*>(message->textContent().utf16())));
+ // TODO:
+ }
+ } else {
+ // Message contains body and attachments
+ QMessageContentContainerIdList contentIds = message->contentIds();
+ foreach (QMessageContentContainerId id, contentIds){
+ QMessageContentContainer container = message->find(id);
+ QMessageContentContainerPrivate* pPrivateContainer = QMessageContentContainerPrivate::implementation(container);
+ if (pPrivateContainer->_id == message->bodyId()) {
+ // ContentContainer is body
+ if (!container.textContent().isEmpty()) {
+ MEmailMessageContent* content = fsMessage->ContentL();
+ MEmailTextContent* textContent = content->AsTextContentOrNull();
+ QByteArray type = container.contentType();
+ QByteArray subType = container.contentSubType();
+ if (type == "text" && subType == "plain") {
+ textContent->SetTextL(MEmailTextContent::EPlainText, TPtrC(reinterpret_cast<const TUint16*>(container.textContent().utf16())));
+ }
+ else if (type == "text" && subType == "html") {
+ textContent->SetTextL(MEmailTextContent::EHtmlText, TPtrC(reinterpret_cast<const TUint16*>(container.textContent().utf16())));
+ }
+ }
+ } else {
+ // ContentContainer is attachment
+ QByteArray filePath = QMessageContentContainerPrivate::attachmentFilename(container);
+ // Replace Qt style path separator "/" with Symbian path separator "\"
+ filePath.replace(QByteArray("/"), QByteArray("\\"));
+ QString temp_path = QString(filePath);
+ TPtrC16 attachmentPath(KNullDesC);
+ attachmentPath.Set(reinterpret_cast<const TUint16*>(temp_path.utf16()));
+ fsMessage->AddAttachmentL(attachmentPath);
+ }
+ }
+ }
+
+ fsMessage->SetSubjectL(TPtrC(reinterpret_cast<const TUint16*>(message->subject().utf16())));
+ fsMessage->SaveChangesL();
+ CleanupStack::PopAndDestroy(fsMessage);
+ CleanupStack::PopAndDestroy(mailbox);
+}
+
+bool CFSEngine::removeMessage(const QMessageId &id, QMessageManager::RemovalOption option)
+{
+ Q_UNUSED(option);
+ bool retVal = false;
+ foreach (QMessageAccount account, m_accounts) {
+ MEmailMessage* message = NULL;
+ TMailboxId mailboxId(stripIdPrefix(account.id().toString()).toInt());
+ MEmailMailbox* mailbox = m_clientApi->MailboxL(mailboxId);
+
+ TMessageId messageId(
+ stripIdPrefix(id.toString()).toInt(),
+ 0,
+ mailboxId);
+
+ TRAPD(err, message = mailbox->MessageL(messageId));
+
+ if (err == KErrNone) {
+ TFolderId folderId(message->ParentFolderId());
+ TRAPD(err2,
+ MEmailFolder* folder = mailbox->FolderL(folderId);
+ REmailMessageIdArray messageIds;
+ messageIds.Append(message->MessageId());
+ folder->DeleteMessagesL(messageIds);
+ folder->Release();
+ );
+ if (err2 == KErrNone)
+ retVal = true;
+ mailbox->Release();
+ break; // no need to continue
+ }
+ mailbox->Release();
+ }
+ return retVal;
+}
+
+bool CFSEngine::showMessage(const QMessageId &id)
+{
+ bool retVal = false;
+ foreach (QMessageAccount account, m_accounts) {
+ MEmailMessage* message = NULL;
+ TMailboxId mailboxId(stripIdPrefix(account.id().toString()).toInt());
+ MEmailMailbox* mailbox = m_clientApi->MailboxL(mailboxId);
+
+ TMessageId messageId(
+ stripIdPrefix(id.toString()).toInt(),
+ 0,
+ mailboxId);
+
+ TRAPD(err, message = mailbox->MessageL(messageId));
+
+ if (err == KErrNone) {
+ TRAPD(err2, message->ShowMessageViewerL());
+ if (err2 == KErrNone)
+ retVal = true;
+ message->Release();
+ mailbox->Release();
+ break; // no need to continue
+ }
+ mailbox->Release();
+ }
+ return retVal;
+}
+
+bool CFSEngine::composeMessage(const QMessage &message)
+{
+ bool retVal = false;
+ MEmailMailbox* mailbox = NULL;
+ TMailboxId mailboxId(stripIdPrefix(message.parentAccountId().toString()).toInt());
+ TRAPD(err, mailbox = m_clientApi->MailboxL(mailboxId));
+ if (err == KErrNone) {
+ TRAPD(err2, mailbox->EditNewMessageL());
+ if (err2 == KErrNone)
+ retVal = true;
+ mailbox->Release();
+ }
+ return retVal;
+}
+
+bool CFSEngine::retrieve(QMessageServicePrivate& privateService, const QMessageId &messageId, const QMessageContentContainerId& id)
+{
+ Q_UNUSED(id);
+ m_privateService = &privateService;
+ bool retVal = false;
+ foreach (QMessageAccount account, m_accounts) {
+ MEmailMessage* message = NULL;
+ TMailboxId mailboxId(stripIdPrefix(account.id().toString()).toInt());
+ MEmailMailbox* mailbox = NULL;
+ TRAPD(mailboxError, mailbox = m_clientApi->MailboxL(mailboxId));
+ if (mailboxError == KErrNone) {
+ TMessageId mId(
+ stripIdPrefix(messageId.toString()).toInt(),
+ 0,
+ mailboxId);
+
+ TRAPD(err, message = mailbox->MessageL(mId));
+ if (err == KErrNone) {
+ MEmailMessageContent* content = NULL;
+ TRAPD(contentError, content = message->ContentL());
+ if (contentError == KErrNone) {
+ TRAPD(err, retrieveAttachmentsL(message));
+ if (err == KErrNone)
+ retVal = true;
+ }
+ }
+ message->Release();
+ mailbox->Release();
+ break; // no need to continue
+ }
+ mailbox->Release();
+ }
+ return retVal;
+}
+
+bool CFSEngine::retrieveBody(QMessageServicePrivate& privateService, const QMessageId& id)
+{
+ bool retVal = false;
+ m_privateService = &privateService;
+ foreach (QMessageAccount account, m_accounts) {
+ MEmailMessage* message = NULL;
+ TMailboxId mailboxId(stripIdPrefix(account.id().toString()).toInt());
+ MEmailMailbox* mailbox = NULL;
+ TRAPD(mailBoxError, mailbox = m_clientApi->MailboxL(mailboxId));
+ if (mailBoxError == KErrNone) {
+ TMessageId messageId(
+ stripIdPrefix(id.toString()).toInt(),
+ 0,
+ mailboxId);
+
+ TRAPD(err, message = mailbox->MessageL(messageId));
+ if (err == KErrNone) {
+ MEmailMessageContent* content = NULL;
+ TRAPD(contentError, content = message->ContentL());
+ if (contentError == KErrNone) {
+ TRAPD(err, retrieveTotalBodyL(content));
+ if (err == KErrNone)
+ retVal = true;
+ }
+ }
+ message->Release();
+ mailbox->Release();
+ break; // no need to continue
+ }
+ mailbox->Release();
+ }
+ return retVal;
+}
+
+void CFSEngine::retrieveTotalBodyL(MEmailMessageContent* aContent)
+{
+ MEmailMultipart* mPart = aContent->AsMultipartOrNull();
+ if (mPart) {
+ TInt partCount = 0;
+ TRAPD(err, partCount = mPart->PartCountL());
+ if (err == KErrNone) {
+ for (TInt i = 0; i < partCount; i++) {
+ MEmailMessageContent* content = NULL;
+ TRAPD(err2, content = mPart->PartByIndexL(i));
+ if (err2 == KErrNone) {
+ retrieveTotalBodyL(content);
+ content->Release();
+ }
+ }
+ }
+ return;
+ }
+
+ MEmailTextContent* textContent = aContent->AsTextContentOrNull();
+ if (textContent) {
+ TInt availableSize = textContent->AvailableSize();
+ TInt totalSize = textContent->TotalSize();
+ if (totalSize > availableSize) {
+ TRAPD(textErr, textContent->FetchL(*this));
+ Q_UNUSED(textErr);
+ }
+ }
+ return;
+}
+
+void CFSEngine::retrieveAttachmentsL(MEmailMessage* aMessage)
+{
+ for (TInt i = 0; i < m_attachments.Count(); i++) {
+ m_attachments[i]->Release();
+ }
+ m_attachments.Reset();
+ TInt count = aMessage->GetAttachmentsL(m_attachments);
+ for(TInt i = 0; i < count; i++) {
+ MEmailAttachment* att = m_attachments[i];
+ int totalSize = att->TotalSize();
+ int availableSize = att->AvailableSize();
+ if (totalSize > availableSize) {
+ TRAPD(err, att->FetchL(*this));
+ Q_UNUSED(err);
+ }
+ }
+}
+
+bool CFSEngine::retrieveHeader(QMessageServicePrivate& privateService, const QMessageId& id)
+{
+ Q_UNUSED(id);
+ Q_UNUSED(privateService);
+ return false;
+}
+
+void CFSEngine::DataFetchedL(const TInt aResult)
+{
+ if (aResult == KErrNone)
+ m_privateService->setFinished(true);
+ else
+ m_privateService->setFinished(false);
+}
+
+bool CFSEngine::exportUpdates(const QMessageAccountId &id)
+{
+ TRAPD(err, exportUpdatesL(id));
+ if (err != KErrNone) {
+ return false;
+ } else {
+ return true;
+ }
+}
+
+void CFSEngine::exportUpdatesL(const QMessageAccountId &id)
+{
+ TMailboxId mailboxId(stripIdPrefix(id.toString()).toInt());
+ MEmailMailbox* mailbox = m_clientApi->MailboxL(mailboxId);
+ mailbox->SynchroniseL(*this);
+ mailbox->Release();
+}
+
+void CFSEngine::MailboxSynchronisedL(TInt aResult)
+{
+ Q_UNUSED(aResult);
+}
+
+bool CFSEngine::removeMessages(const QMessageFilter& /*filter*/, QMessageManager::RemovalOption /*option*/)
+{
+ return false;
+}
+
+void CFSEngine::handleNestedFiltersFromMessageFilter(QMessageFilter &filter) const
+{
+ QMessageFilterPrivate* pMFFilter = QMessageFilterPrivate::implementation(filter);
+ if (pMFFilter->_filterList.count() > 0) {
+ int filterListCount = pMFFilter->_filterList.count();
+ for (int i=0; i < filterListCount; i++) {
+ for (int j=0; j < pMFFilter->_filterList[i].count(); j++) {
+ QMessageFilterPrivate* pMFFilter2 = QMessageFilterPrivate::implementation(pMFFilter->_filterList[i][j]);
+ if (pMFFilter2->_field == QMessageFilterPrivate::ParentAccountIdFilter) {
+ QMessageAccountIdList accountIds = queryAccounts(*pMFFilter2->_accountFilter, QMessageAccountSortOrder(), 0, 0);
+ QMessageDataComparator::InclusionComparator cmp(static_cast<QMessageDataComparator::InclusionComparator>(pMFFilter2->_comparatorValue));
+ if (accountIds.count() > 0) {
+ pMFFilter->_filterList[i].removeAt(j);
+ if (cmp == QMessageDataComparator::Includes) {
+ for (int x = 0; x < accountIds.count(); x++) {
+ if (x == 0) {
+ if (x+1 < accountIds.count()) {
+ pMFFilter->_filterList.append(pMFFilter->_filterList[i]);
+ }
+ pMFFilter->_filterList[i].append(QMessageFilter::byParentAccountId(accountIds[x],QMessageDataComparator::Equal));
+ qSort(pMFFilter->_filterList[i].begin(), pMFFilter->_filterList[i].end(), QMessageFilterPrivate::lessThan);
+ } else {
+ if (x+1 < accountIds.count()) {
+ pMFFilter->_filterList.append(pMFFilter->_filterList[pMFFilter->_filterList.count()-1]);
+ pMFFilter->_filterList[pMFFilter->_filterList.count()-2].append(QMessageFilter::byParentAccountId(accountIds[x],QMessageDataComparator::Equal));
+ qSort(pMFFilter->_filterList[pMFFilter->_filterList.count()-2].begin(), pMFFilter->_filterList[pMFFilter->_filterList.count()-2].end(), QMessageFilterPrivate::lessThan);
+ } else {
+ pMFFilter->_filterList[pMFFilter->_filterList.count()-1].append(QMessageFilter::byParentAccountId(accountIds[x],QMessageDataComparator::Equal));
+ qSort(pMFFilter->_filterList[pMFFilter->_filterList.count()-1].begin(), pMFFilter->_filterList[pMFFilter->_filterList.count()-1].end(), QMessageFilterPrivate::lessThan);
+ }
+ }
+ }
+ } else { // Excludes
+ for (int x = 0; x < accountIds.count(); x++) {
+ pMFFilter->_filterList[i].append(QMessageFilter::byParentAccountId(accountIds[x],QMessageDataComparator::NotEqual));
+ }
+ qSort(pMFFilter->_filterList[i].begin(), pMFFilter->_filterList[i].end(), QMessageFilterPrivate::lessThan);
+ }
+ } else {
+ delete pMFFilter2->_accountFilter;
+ pMFFilter2->_accountFilter = 0;
+ pMFFilter2->_field = QMessageFilterPrivate::Id;
+ qSort(pMFFilter->_filterList[i].begin(), pMFFilter->_filterList[i].end(), QMessageFilterPrivate::lessThan);
+ }
+ } else if (pMFFilter2->_field == QMessageFilterPrivate::ParentFolderIdFilter) {
+ QMessageFolderIdList folderIds = queryFolders(*pMFFilter2->_folderFilter, QMessageFolderSortOrder(), 0, 0);
+ QMessageDataComparator::InclusionComparator cmp(static_cast<QMessageDataComparator::InclusionComparator>(pMFFilter2->_comparatorValue));
+ if (folderIds.count() > 0) {
+ pMFFilter->_filterList[i].removeAt(j);
+ if (cmp == QMessageDataComparator::Includes) {
+ for (int x = 0; x < folderIds.count(); x++) {
+ if (x == 0) {
+ if (x+1 < folderIds.count()) {
+ pMFFilter->_filterList.append(pMFFilter->_filterList[i]);
+ }
+ pMFFilter->_filterList[i].append(QMessageFilter::byParentFolderId(folderIds[x],QMessageDataComparator::Equal));
+ qSort(pMFFilter->_filterList[i].begin(), pMFFilter->_filterList[i].end(), QMessageFilterPrivate::lessThan);
+ } else {
+ if (x+1 < folderIds.count()) {
+ pMFFilter->_filterList.append(pMFFilter->_filterList[pMFFilter->_filterList.count()-1]);
+ pMFFilter->_filterList[pMFFilter->_filterList.count()-2].append(QMessageFilter::byParentFolderId(folderIds[x],QMessageDataComparator::Equal));
+ qSort(pMFFilter->_filterList[pMFFilter->_filterList.count()-2].begin(), pMFFilter->_filterList[pMFFilter->_filterList.count()-2].end(), QMessageFilterPrivate::lessThan);
+ } else {
+ pMFFilter->_filterList[pMFFilter->_filterList.count()-1].append(QMessageFilter::byParentFolderId(folderIds[x],QMessageDataComparator::Equal));
+ qSort(pMFFilter->_filterList[pMFFilter->_filterList.count()-1].begin(), pMFFilter->_filterList[pMFFilter->_filterList.count()-1].end(), QMessageFilterPrivate::lessThan);
+ }
+ }
+ }
+ } else { // Excludes
+ for (int x = 0; x < folderIds.count(); x++) {
+ pMFFilter->_filterList[i].append(QMessageFilter::byParentFolderId(folderIds[x],QMessageDataComparator::NotEqual));
+ }
+ qSort(pMFFilter->_filterList[i].begin(), pMFFilter->_filterList[i].end(), QMessageFilterPrivate::lessThan);
+ }
+ } else {
+ delete pMFFilter2->_folderFilter;
+ pMFFilter2->_folderFilter = 0;
+ pMFFilter2->_field = QMessageFilterPrivate::Id;
+ qSort(pMFFilter->_filterList[i].begin(), pMFFilter->_filterList[i].end(), QMessageFilterPrivate::lessThan);
+ }
+ } else {
+ break;
+ }
+ }
+ }
+ } else {
+ if (pMFFilter->_field == QMessageFilterPrivate::ParentAccountIdFilter) {
+ QMessageAccountIdList accountIds = queryAccounts(*pMFFilter->_accountFilter, QMessageAccountSortOrder(), 0, 0);
+ QMessageDataComparator::InclusionComparator cmp(static_cast<QMessageDataComparator::InclusionComparator>(pMFFilter->_comparatorValue));
+ if (accountIds.count() > 0) {
+ for (int i=0; i < accountIds.count(); i++) {
+ if (i == 0) {
+ delete pMFFilter->_accountFilter;
+ pMFFilter->_accountFilter = 0;
+ pMFFilter->_field = QMessageFilterPrivate::ParentAccountId;
+ pMFFilter->_value = accountIds[0].toString();
+ pMFFilter->_comparatorType = QMessageFilterPrivate::Equality;
+ if (cmp == QMessageDataComparator::Includes) {
+ pMFFilter->_comparatorValue = static_cast<int>(QMessageDataComparator::Equal);
+ } else { // Excludes
+ pMFFilter->_comparatorValue = static_cast<int>(QMessageDataComparator::NotEqual);
+ }
+ } else {
+ if (cmp == QMessageDataComparator::Includes) {
+ filter |= QMessageFilter::byParentAccountId(accountIds[i],QMessageDataComparator::Equal);
+ } else { // Excludes
+ filter &= QMessageFilter::byParentAccountId(accountIds[i],QMessageDataComparator::NotEqual);
+ }
+ }
+ }
+ } else {
+ delete pMFFilter->_accountFilter;
+ pMFFilter->_accountFilter = 0;
+ pMFFilter->_field = QMessageFilterPrivate::Id;
+ }
+ } else if (pMFFilter->_field == QMessageFilterPrivate::ParentFolderIdFilter) {
+ QMessageFolderIdList folderIds = queryFolders(*pMFFilter->_folderFilter, QMessageFolderSortOrder(), 0, 0);
+ QMessageDataComparator::InclusionComparator cmp(static_cast<QMessageDataComparator::InclusionComparator>(pMFFilter->_comparatorValue));
+ if (folderIds.count() > 0) {
+ for (int i=0; i < folderIds.count(); i++) {
+ if (i == 0) {
+ delete pMFFilter->_folderFilter;
+ pMFFilter->_folderFilter = 0;
+ pMFFilter->_field = QMessageFilterPrivate::ParentFolderId;
+ pMFFilter->_value = folderIds[0].toString();
+ pMFFilter->_comparatorType = QMessageFilterPrivate::Equality;
+ if (cmp == QMessageDataComparator::Includes) {
+ pMFFilter->_comparatorValue = static_cast<int>(QMessageDataComparator::Equal);
+ } else { // Excludes
+ pMFFilter->_comparatorValue = static_cast<int>(QMessageDataComparator::NotEqual);
+ }
+ } else {
+ if (cmp == QMessageDataComparator::Includes) {
+ filter |= QMessageFilter::byParentFolderId(folderIds[i],QMessageDataComparator::Equal);
+ } else { // Excludes
+ filter &= QMessageFilter::byParentFolderId(folderIds[i],QMessageDataComparator::NotEqual);
+ }
+ }
+ }
+ } else {
+ delete pMFFilter->_folderFilter;
+ pMFFilter->_folderFilter = 0;
+ pMFFilter->_field = QMessageFilterPrivate::Id;
+ }
+ }
+ }
+}
+
+bool CFSEngine::queryMessages(QMessageServicePrivate& privateService, const QMessageFilter &filter, const QMessageSortOrder &sortOrder, uint limit, uint offset) const
+{
+ TRAPD(err, queryMessagesL(privateService, filter, sortOrder, limit, offset));
+ if (err != KErrNone) {
+ return false;
+ }
+ return true;
+}
+
+
+void CFSEngine::queryMessagesL(QMessageServicePrivate& privateService, const QMessageFilter &filter, const QMessageSortOrder &sortOrder, uint limit, uint offset) const
+{
+
+ FSMessageQueryInfo queryInfo;
+ queryInfo.operationId = ++m_operationIds;
+ if (queryInfo.operationId == 100000) {
+ queryInfo.operationId = 1;
+ }
+ queryInfo.isQuery = true;
+ queryInfo.filter = filter;
+ queryInfo.sortOrder = sortOrder;
+ queryInfo.offset = offset;
+ queryInfo.limit = limit;
+ queryInfo.findOperation = new CFSMessagesFindOperation((CFSEngine&)*this, queryInfo.operationId);
+ queryInfo.privateService = &privateService;
+ queryInfo.currentFilterListIndex = 0;
+ m_messageQueries.append(queryInfo);
+
+ handleNestedFiltersFromMessageFilter(m_messageQueries[m_messageQueries.count()-1].filter);
+
+ QMessageFilterPrivate* pf = QMessageFilterPrivate::implementation(m_messageQueries[m_messageQueries.count()-1].filter);
+ if (pf->_filterList.count() == 0) {
+ queryInfo.findOperation->filterAndOrderMessages(m_messageQueries[m_messageQueries.count()-1].filter,
+ m_messageQueries[m_messageQueries.count()-1].sortOrder);
+ } else {
+ queryInfo.findOperation->filterAndOrderMessages(pf->_filterList[0], m_messageQueries[m_messageQueries.count()-1].sortOrder);
+ }
+}
+
+bool CFSEngine::queryMessages(QMessageServicePrivate& privateService, const QMessageFilter &filter, const QString &body, QMessageDataComparator::MatchFlags matchFlags, const QMessageSortOrder &sortOrder, uint limit, uint offset) const
+{
+ TRAPD(err, queryMessagesL(privateService, filter, body, matchFlags, sortOrder, limit, offset));
+ if (err != KErrNone) {
+ return false;
+ }
+ return true;
+}
+
+void CFSEngine::queryMessagesL(QMessageServicePrivate& privateService, const QMessageFilter &filter, const QString &body, QMessageDataComparator::MatchFlags matchFlags, const QMessageSortOrder &sortOrder, uint limit, uint offset) const
+{
+ FSMessageQueryInfo queryInfo;
+ queryInfo.operationId = ++m_operationIds;
+ if (queryInfo.operationId == 100000) {
+ queryInfo.operationId = 1;
+ }
+ queryInfo.isQuery = true;
+ queryInfo.body = body;
+ queryInfo.matchFlags = matchFlags;
+ queryInfo.filter = filter;
+ queryInfo.sortOrder = sortOrder;
+ queryInfo.offset = offset;
+ queryInfo.limit = limit;
+ queryInfo.findOperation = new CFSMessagesFindOperation((CFSEngine&)*this, queryInfo.operationId);
+ queryInfo.privateService = &privateService;
+ queryInfo.currentFilterListIndex = 0;
+ m_messageQueries.append(queryInfo);
+
+ handleNestedFiltersFromMessageFilter(m_messageQueries[m_messageQueries.count()-1].filter);
+
+ QMessageFilterPrivate* pf = QMessageFilterPrivate::implementation(m_messageQueries[m_messageQueries.count()-1].filter);
+ if (pf->_filterList.count() == 0) {
+ queryInfo.findOperation->filterAndOrderMessages(m_messageQueries[m_messageQueries.count()-1].filter,
+ m_messageQueries[m_messageQueries.count()-1].sortOrder,
+ body,
+ matchFlags);
+ } else {
+ queryInfo.findOperation->filterAndOrderMessages(pf->_filterList[0],
+ m_messageQueries[m_messageQueries.count()-1].sortOrder,
+ body,
+ matchFlags);
+ }
+}
+
+bool CFSEngine::countMessages(QMessageServicePrivate& privateService, const QMessageFilter &filter)
+{
+ TRAPD(err, countMessagesL(privateService, filter));
+ if (err != KErrNone) {
+ return false;
+ }
+ return true;
+}
+
+void CFSEngine::countMessagesL(QMessageServicePrivate& privateService, const QMessageFilter &filter)
+{
+ FSMessageQueryInfo queryInfo;
+ queryInfo.operationId = ++m_operationIds;
+ if (queryInfo.operationId == 100000) {
+ queryInfo.operationId = 1;
+ }
+ queryInfo.isQuery = false;
+ queryInfo.matchFlags = 0;
+ queryInfo.filter = filter;
+ queryInfo.sortOrder = QMessageSortOrder();
+ queryInfo.offset = 0;
+ queryInfo.limit = 0;
+ queryInfo.findOperation = new CFSMessagesFindOperation((CFSEngine&)*this, queryInfo.operationId);
+ queryInfo.privateService = &privateService;
+ queryInfo.currentFilterListIndex = 0;
+ queryInfo.count = 0;
+ m_messageQueries.append(queryInfo);
+
+ handleNestedFiltersFromMessageFilter(m_messageQueries[m_messageQueries.count()-1].filter);
+
+ QMessageFilterPrivate* pf = QMessageFilterPrivate::implementation(m_messageQueries[m_messageQueries.count()-1].filter);
+ if (pf->_filterList.count() == 0) {
+ queryInfo.findOperation->filterAndOrderMessages(m_messageQueries[m_messageQueries.count()-1].filter,
+ m_messageQueries[m_messageQueries.count()-1].sortOrder);
+ } else {
+ queryInfo.findOperation->filterAndOrderMessages(pf->_filterList[0], m_messageQueries[m_messageQueries.count()-1].sortOrder);
+ }
+}
+
+void CFSEngine::filterAndOrderMessagesReady(bool success, int operationId, QMessageIdList ids, int numberOfHandledFilters,
+ bool resultSetOrdered)
+{
+ int index=0;
+ for (; index < m_messageQueries.count(); index++) {
+ if (m_messageQueries[index].operationId == operationId) {
+ break;
+ }
+ }
+
+ if (success) {
+ // If there are unhandled filters, loop through all filters and do filtering for ids using unhandled filters.
+ QMessageFilterPrivate* pf = QMessageFilterPrivate::implementation(m_messageQueries[index].filter);
+ if (pf->_filterList.count() > 0) {
+ if (pf->_filterList[m_messageQueries[index].currentFilterListIndex].count() > numberOfHandledFilters) {
+ for (int i=0; i < ids.count(); i++) {
+ QMessage msg = message(ids[i]);
+ for (int j=numberOfHandledFilters; j < pf->_filterList[m_messageQueries[index].currentFilterListIndex].count(); j++) {
+ QMessageFilterPrivate* pf2 = QMessageFilterPrivate::implementation(pf->_filterList[m_messageQueries[index].currentFilterListIndex][j]);
+ if (!pf2->filter(msg)) {
+ ids.removeAt(i);
+ i--;
+ break;
+ }
+ }
+ }
+ }
+ }
+ if (pf->_filterList.count() > 0) {
+ // Filter contains filterlist (or filterlists), not just one single filter
+ if (m_messageQueries[index].currentFilterListIndex == 0) {
+ m_messageQueries[index].ids << ids;
+ m_messageQueries[index].count = ids.count();
+ } else {
+ // Append new ids to resultset
+ for (int i=0; i < ids.count(); i++) {
+ if (!m_messageQueries[index].ids.contains(ids[i])) {
+ m_messageQueries[index].ids.append(ids[i]);
+ m_messageQueries[index].count++;;
+ }
+ }
+ }
+
+ m_messageQueries[index].currentFilterListIndex++;
+ if (m_messageQueries[index].currentFilterListIndex < pf->_filterList.count()) {
+ // There are still unhandled filter lists left
+ m_messageQueries[index].findOperation->filterAndOrderMessages(pf->_filterList[m_messageQueries[index].currentFilterListIndex],
+ m_messageQueries[index].sortOrder,
+ m_messageQueries[index].body,
+ m_messageQueries[index].matchFlags);
+ return;
+ } else {
+ // All filters successfully handled
+ if (m_messageQueries[index].isQuery) {
+ if (!m_messageQueries[index].sortOrder.isEmpty()) {
+ // Make sure that messages are correctly ordered
+ orderMessages(m_messageQueries[index].ids, m_messageQueries[index].sortOrder);
+ }
+ applyOffsetAndLimitToMsgIds(m_messageQueries[index].ids,
+ m_messageQueries[index].offset,
+ m_messageQueries[index].limit);
+ m_messageQueries[index].privateService->messagesFound(m_messageQueries[index].ids, true, true);
+
+ //emit m_messageQueries[index].privateService->messagesFound(m_messageQueries[index].ids);
+ } else {
+ m_messageQueries[index].privateService->messagesCounted(m_messageQueries[index].count);
+ }
+ }
+ } else {
+ // There was only one single filter to handle
+ if (numberOfHandledFilters == 0) {
+ // The one and only filter was not handled
+ // => Do filtering for all returned messages
+ for (int i=ids.count()-1; i >= 0; i--) {
+ QMessage msg = message(ids[i]);
+ if (!pf->filter(msg)) {
+ ids.removeAt(i);
+ }
+ }
+ }
+ // => All filters successfully handled
+ if (m_messageQueries[index].isQuery) {
+ // Make sure that messages are correctly ordered
+ if (!m_messageQueries[index].sortOrder.isEmpty() && !resultSetOrdered) {
+ orderMessages(ids, m_messageQueries[index].sortOrder);
+ }
+ // Handle offest & limit
+ applyOffsetAndLimitToMsgIds(ids, m_messageQueries[index].offset, m_messageQueries[index].limit);
+ //emit m_messageQueries[index].privateService->messagesFound(ids);
+ m_messageQueries[index].privateService->messagesFound(ids, true, true);
+ } else {
+ m_messageQueries[index].privateService->messagesCounted(ids.count());
+ }
+ }
+ } else {
+ m_messageQueries[index].privateService->_active = false;
+ if (m_messageQueries[index].privateService->_error == QMessageManager::NoError) {
+ m_messageQueries[index].privateService->_error = QMessageManager::RequestIncomplete;
+ }
+ }
+
+ delete m_messageQueries[index].findOperation;
+ m_messageQueries.removeAt(index);
+}
+
+void CFSEngine::applyOffsetAndLimitToMsgIds(QMessageIdList& idList, int offset, int limit) const
+{
+ if (offset > 0) {
+ if (offset > idList.count()) {
+ idList.clear();
+ } else {
+ for (int i = 0; i < offset; i++) {
+ idList.removeFirst();
+ }
+ }
+ }
+ if (limit > 0) {
+ for (int i = idList.count()-1; i >= limit; i--) {
+ idList.removeAt(i);
+ }
+ }
+}
+
+QMessageManager::NotificationFilterId CFSEngine::registerNotificationFilter(QMessageStorePrivate& aPrivateStore,
+ const QMessageFilter &filter, QMessageManager::NotificationFilterId aId)
+{
+ ipMessageStorePrivate = &aPrivateStore;
+ iListenForNotifications = true;
+
+ int filterId = aId;
+ if (filterId == 0)
+ filterId = ++m_filterId;
+ m_filters.insert(filterId, filter);
+ return filterId;
+}
+
+void CFSEngine::unregisterNotificationFilter(QMessageManager::NotificationFilterId notificationFilterId)
+{
+ m_filters.remove(notificationFilterId);
+ if (m_filters.count() == 0) {
+ iListenForNotifications = false;
+ }
+}
+void CFSEngine::handleNestedFiltersFromFolderFilter(QMessageFolderFilter &filter) const
+{
+ QMessageFolderFilterPrivate* pMFFilter = QMessageFolderFilterPrivate::implementation(filter);
+ if (pMFFilter->_filterList.count() > 0) {
+ int filterListCount = pMFFilter->_filterList.count();
+ for (int i=0; i < filterListCount; i++) {
+ for (int j=0; j < pMFFilter->_filterList[i].count(); j++) {
+ QMessageFolderFilterPrivate* pMFFilter2 = QMessageFolderFilterPrivate::implementation(pMFFilter->_filterList[i][j]);
+ if (pMFFilter2->_field == QMessageFolderFilterPrivate::ParentAccountIdFilter) {
+ QMessageAccountIdList accountIds = queryAccounts(*pMFFilter2->_accountFilter, QMessageAccountSortOrder(), 0, 0);
+ QMessageDataComparator::InclusionComparator cmp(static_cast<QMessageDataComparator::InclusionComparator>(pMFFilter2->_comparatorValue));
+ if (accountIds.count() > 0) {
+ pMFFilter->_filterList[i].removeAt(j);
+ if (cmp == QMessageDataComparator::Includes) {
+ for (int x = 0; x < accountIds.count(); x++) {
+ if (x == 0) {
+ if (x+1 < accountIds.count()) {
+ pMFFilter->_filterList.append(pMFFilter->_filterList[i]);
+ }
+ pMFFilter->_filterList[i].append(QMessageFolderFilter::byParentAccountId(accountIds[x],QMessageDataComparator::Equal));
+ qSort(pMFFilter->_filterList[i].begin(), pMFFilter->_filterList[i].end(), QMessageFolderFilterPrivate::lessThan);
+ } else {
+ if (x+1 < accountIds.count()) {
+ pMFFilter->_filterList.append(pMFFilter->_filterList[pMFFilter->_filterList.count()-1]);
+ pMFFilter->_filterList[pMFFilter->_filterList.count()-2].append(QMessageFolderFilter::byParentAccountId(accountIds[x],QMessageDataComparator::Equal));
+ qSort(pMFFilter->_filterList[pMFFilter->_filterList.count()-2].begin(), pMFFilter->_filterList[pMFFilter->_filterList.count()-2].end(), QMessageFolderFilterPrivate::lessThan);
+ } else {
+ pMFFilter->_filterList[pMFFilter->_filterList.count()-1].append(QMessageFolderFilter::byParentAccountId(accountIds[x],QMessageDataComparator::Equal));
+ qSort(pMFFilter->_filterList[pMFFilter->_filterList.count()-1].begin(), pMFFilter->_filterList[pMFFilter->_filterList.count()-1].end(), QMessageFolderFilterPrivate::lessThan);
+ }
+ }
+ }
+ } else { // Excludes
+ for (int x = 0; x < accountIds.count(); x++) {
+ pMFFilter->_filterList[i].append(QMessageFolderFilter::byParentAccountId(accountIds[x],QMessageDataComparator::NotEqual));
+ }
+ qSort(pMFFilter->_filterList[i].begin(), pMFFilter->_filterList[i].end(), QMessageFolderFilterPrivate::lessThan);
+ }
+ } else {
+ delete pMFFilter2->_accountFilter;
+ pMFFilter2->_accountFilter = 0;
+ pMFFilter2->_field = QMessageFolderFilterPrivate::Id;
+ qSort(pMFFilter->_filterList[i].begin(), pMFFilter->_filterList[i].end(), QMessageFolderFilterPrivate::lessThan);
+ }
+ } else {
+ break;
+ }
+ }
+ }
+ } else {
+ if (pMFFilter->_field == QMessageFolderFilterPrivate::ParentAccountIdFilter) {
+ QMessageAccountIdList accountIds = queryAccounts(*pMFFilter->_accountFilter, QMessageAccountSortOrder(), 0, 0);
+ QMessageDataComparator::InclusionComparator cmp(static_cast<QMessageDataComparator::InclusionComparator>(pMFFilter->_comparatorValue));
+ if (accountIds.count() > 0) {
+ for (int i=0; i < accountIds.count(); i++) {
+ if (i == 0) {
+ delete pMFFilter->_accountFilter;
+ pMFFilter->_accountFilter = 0;
+ pMFFilter->_field = QMessageFolderFilterPrivate::ParentAccountId;
+ pMFFilter->_value = accountIds[0].toString();
+ pMFFilter->_comparatorType = QMessageFolderFilterPrivate::Equality;
+ if (cmp == QMessageDataComparator::Includes) {
+ pMFFilter->_comparatorValue = static_cast<int>(QMessageDataComparator::Equal);
+ } else { // Excludes
+ pMFFilter->_comparatorValue = static_cast<int>(QMessageDataComparator::NotEqual);
+ }
+ } else {
+ if (cmp == QMessageDataComparator::Includes) {
+ filter |= QMessageFolderFilter::byParentAccountId(accountIds[i],QMessageDataComparator::Equal);
+ } else { // Excludes
+ filter &= QMessageFolderFilter::byParentAccountId(accountIds[i],QMessageDataComparator::NotEqual);
+ }
+ }
+ }
+ } else {
+ delete pMFFilter->_accountFilter;
+ pMFFilter->_accountFilter = 0;
+ pMFFilter->_field = QMessageFolderFilterPrivate::Id;
+ }
+ }
+ }
+}
+
+QMessageFolderIdList CFSEngine::queryFolders(const QMessageFolderFilter &filter, const QMessageFolderSortOrder &sortOrder, uint limit, uint offset) const
+{
+ QMessageFolderIdList ids;
+
+ QMessageFolderFilter copyOfFilter = filter;
+
+ handleNestedFiltersFromFolderFilter(copyOfFilter);
+
+ QMessageFolderFilterPrivate* pMFFilter = QMessageFolderFilterPrivate::implementation(copyOfFilter);
+
+ if (pMFFilter->_filterList.count() > 0) {
+ for (int i=0; i < pMFFilter->_filterList.count(); i++) {
+ bool filterHandled;
+ QMessageFolderIdList ids2 = filterMessageFolders(pMFFilter->_filterList[i][0], filterHandled);
+ for (int x=ids2.count()-1; x >= 0; x--) {
+ QMessageFolder mf = folder(ids2[x]);
+ int j = filterHandled ? 1 : 0;
+ for (; j < pMFFilter->_filterList[i].count(); j++) {
+ if (!QMessageFolderFilterPrivate::implementation(pMFFilter->_filterList[i][j])->filter(mf)) {
+ ids2.removeAt(x);
+ break;
+ }
+ }
+ }
+ for (int j=0; j < ids2.count(); j++) {
+ if (!ids.contains(ids2[j])) {
+ ids.append(ids2[j]);
+ }
+ }
+ }
+ } else {
+ bool filterHandled;
+ ids = filterMessageFolders(copyOfFilter, filterHandled);
+ if (!filterHandled) {
+ for (int i=ids.count()-1; i >= 0; i--) {
+ if (!QMessageFolderFilterPrivate::implementation(copyOfFilter)->filter(ids[i])) {
+ ids.removeAt(i);
+ }
+ }
+ }
+ }
+
+ if (!sortOrder.isEmpty()) {
+ orderFolders(ids, sortOrder);
+ }
+
+ applyOffsetAndLimitToMsgFolderIds(ids, offset, limit);
+
+ return ids;
+}
+
+void CFSEngine::applyOffsetAndLimitToMsgFolderIds(QMessageFolderIdList& idList, int offset, int limit) const
+{
+ if (offset > 0) {
+ if (offset > idList.count()) {
+ idList.clear();
+ } else {
+ for (int i = 0; i < offset; i++) {
+ idList.removeFirst();
+ }
+ }
+ }
+ if (limit > 0) {
+ for (int i = idList.count()-1; i >= limit; i--) {
+ idList.removeAt(i);
+ }
+ }
+}
+
+int CFSEngine::countFolders(const QMessageFolderFilter &filter) const
+{
+ return queryFolders(filter, QMessageFolderSortOrder(), 0, 0).count();
+}
+
+QMessageFolder CFSEngine::folder(const QMessageFolderId &id) const
+{
+ //return QMessageFolder();
+
+ QMessageFolder folder;
+ TRAPD(err, folder = folderL(id));
+ Q_UNUSED(err)
+
+ return folder;
+}
+
+QMessageFolder CFSEngine::folderL(const QMessageFolderId &id) const
+{
+ QMessageFolder folder;
+ MEmailMailbox* mailbox = NULL;
+ QMessageFolderId parentId;
+ QMessageAccountId accountId;
+
+ // get account containing folder
+ TRAPD(err, updateEmailAccountsL());
+ Q_UNUSED(err)
+ foreach (QMessageAccount value, m_accounts) {
+ accountId = value.id();
+ QMessageFolderIdList ids = folderIdsByAccountIdL(accountId);
+ if (ids.contains(id)) {
+ TMailboxId mailboxId(stripIdPrefix(accountId.toString()).toInt());
+ mailbox = m_clientApi->MailboxL(mailboxId);
+ CleanupReleasePushL(*mailbox);
+ TFolderId folderId(stripIdPrefix(id.toString()).toInt(), mailbox->MailboxId());
+ MEmailFolder* emailFolder = mailbox->FolderL(folderId);
+ CleanupReleasePushL(*emailFolder);
+ QString name = QString::fromUtf16(emailFolder->Name().Ptr(), emailFolder->Name().Length());
+ folder = QMessageFolderPrivate::from(id, accountId, parentId, name, name);
+ CleanupStack::PopAndDestroy(emailFolder);
+ CleanupStack::PopAndDestroy(mailbox);
+ break;
+ }
+ }
+ return folder;
+}
+
+QMessageFolderIdList CFSEngine::filterMessageFolders(const QMessageFolderFilter& filter, bool& filterHandled) const
+{
+ QMessageFolderIdList ids;
+ TRAPD(err, ids = filterMessageFoldersL(filter, filterHandled));
+ Q_UNUSED(err)
+ return ids;
+}
+
+QMessageFolderIdList CFSEngine::filterMessageFoldersL(const QMessageFolderFilter& filter, bool& filterHandled) const
+{
+ filterHandled = false;
+ QMessageFolderIdList ids;
+
+ if (filter.isEmpty()) {
+ QMessageFolderFilterPrivate* pf = QMessageFolderFilterPrivate::implementation(filter);
+ if (!pf->_notFilter) {
+ ids = allFolders();
+ }
+ filterHandled = true;
+ } else {
+ QMessageFolderFilterPrivate* pf = QMessageFolderFilterPrivate::implementation(filter);
+ if (!pf->_valid) {
+ return QMessageFolderIdList();
+ }
+
+ switch (pf->_field) {
+ case QMessageFolderFilterPrivate::Id:
+ {
+ if (pf->_comparatorType == QMessageFolderFilterPrivate::Equality) {
+ QMessageDataComparator::EqualityComparator cmp(static_cast<QMessageDataComparator::EqualityComparator>(pf->_comparatorValue));
+ if (pf->_value.toString().length() > QString(SymbianHelpers::mtmPrefix).length()) {
+ bool folderOk = false;
+ MEmailMailbox* mailbox = NULL;
+ MEmailFolder* folder = NULL;;
+ if (fsFolderL(QMessageFolderId(pf->_value.toString()), mailbox, folder)) {
+ folderOk = true;
+ // cleanup
+ folder->Release();
+ mailbox->Release();
+ }
+ if (cmp == QMessageDataComparator::Equal) {
+ if (folderOk) {
+ ids.append(QMessageFolderId(pf->_value.toString()));
+ }
+ } else { // NotEqual
+ ids = allFolders();
+ if (folderOk) {
+ ids.removeOne(QMessageFolderId(pf->_value.toString()));
+ }
+ }
+ } else {
+ if (cmp == QMessageDataComparator::NotEqual) {
+ ids = allFolders();
+ }
+ }
+ filterHandled = true;
+ } else if (pf->_comparatorType == QMessageFolderFilterPrivate::Inclusion) {
+ QMessageDataComparator::InclusionComparator cmp(static_cast<QMessageDataComparator::InclusionComparator>(pf->_comparatorValue));
+ if (pf->_ids.count() > 0) { // QMessageIdList
+ QMessageFolderIdList ids2;
+ for (int i=0; i < pf->_ids.count(); i++) {
+ MEmailMailbox* mailbox = NULL;
+ MEmailFolder* folder = NULL;
+ if (fsFolderL(QMessageFolderId(pf->_ids[i]), mailbox, folder)) {
+ ids2.append(pf->_ids[i]);
+ // cleanup
+ folder->Release();
+ mailbox->Release();
+ }
+ }
+ if (cmp == QMessageDataComparator::Includes) {
+ ids << ids2;
+ } else { // Excludes
+ ids = allFolders();
+ for (int i=0; i < ids2.count(); i++) {
+ ids.removeOne(ids2[i]);
+ }
+ }
+ filterHandled = true;
+ } else {
+ // Empty QMessageIdList as a list
+ if (cmp == QMessageDataComparator::Excludes) {
+ ids = allFolders();
+ }
+ filterHandled = true;
+
+ // QMessageFilter
+ /*if (cmp == QMessageDataComparator::Includes) {
+ // TODO:
+ } else { // Excludes
+ // TODO:
+ }*/
+ }
+ }
+ break;
+ }
+ case QMessageFolderFilterPrivate::Name:
+ {
+ if (pf->_comparatorType == QMessageFolderFilterPrivate::Equality) {
+ QMessageDataComparator::EqualityComparator cmp(static_cast<QMessageDataComparator::EqualityComparator>(pf->_comparatorValue));
+ if (cmp == QMessageDataComparator::Equal) {
+ // TODO:
+ } else { // NotEqual
+ // TODO:
+ }
+ } else if (pf->_comparatorType == QMessageFolderFilterPrivate::Inclusion) {
+ QMessageDataComparator::InclusionComparator cmp(static_cast<QMessageDataComparator::InclusionComparator>(pf->_comparatorValue));
+ if (cmp == QMessageDataComparator::Includes) {
+ // TODO:
+ } else { // Excludes
+ if (pf->_value.toString().isEmpty() || pf->_value.toString().length() == 0) {
+ filterHandled = true;
+ }
+ }
+ }
+ break;
+ }
+ case QMessageFolderFilterPrivate::Path:
+ {
+ if (pf->_comparatorType == QMessageFolderFilterPrivate::Equality) {
+ QMessageDataComparator::EqualityComparator cmp(static_cast<QMessageDataComparator::EqualityComparator>(pf->_comparatorValue));
+ if (cmp == QMessageDataComparator::Equal) {
+ // TODO:
+ } else { // NotEqual
+ // TODO:
+ }
+ } else if (pf->_comparatorType == QMessageFolderFilterPrivate::Inclusion) {
+ QMessageDataComparator::InclusionComparator cmp(static_cast<QMessageDataComparator::InclusionComparator>(pf->_comparatorValue));
+ if (cmp == QMessageDataComparator::Includes) {
+ // TODO:
+ } else { // Excludes
+ if (pf->_value.toString().isEmpty() || pf->_value.toString().length() == 0) {
+ filterHandled = true;
+ }
+ }
+ }
+ break;
+ }
+ case QMessageFolderFilterPrivate::ParentAccountId:
+ {
+ if (pf->_comparatorType == QMessageFolderFilterPrivate::Equality) {
+ QMessageDataComparator::EqualityComparator cmp(static_cast<QMessageDataComparator::EqualityComparator>(pf->_comparatorValue));
+ if (cmp == QMessageDataComparator::Equal) {
+ if (pf->_value.toString().length() > 0) {
+ ids = folderIdsByAccountIdL(QMessageAccountId(pf->_value.toString()));
+ }
+ } else { // NotEqual
+ ids = allFolders();
+ if (pf->_value.toString().length() > 0) {
+ QMessageFolderIdList ids2 = folderIdsByAccountIdL(QMessageAccountId(pf->_value.toString()));
+ for (int i = 0; i < ids2.count(); i++) {
+ ids.removeOne(ids2[i]);
+ }
+ }
+ }
+ filterHandled = true;
+ } else if (pf->_comparatorType == QMessageFolderFilterPrivate::Inclusion) {
+ QMessageDataComparator::InclusionComparator cmp(static_cast<QMessageDataComparator::InclusionComparator>(pf->_comparatorValue));
+ if (cmp == QMessageDataComparator::Includes) {
+ // TODO:
+ } else { // Excludes
+ // TODO:
+ }
+ }
+ break;
+ }
+ case QMessageFolderFilterPrivate::ParentFolderId:
+ {
+ if (pf->_comparatorType == QMessageFolderFilterPrivate::Equality) {
+ QMessageDataComparator::EqualityComparator cmp(static_cast<QMessageDataComparator::EqualityComparator>(pf->_comparatorValue));
+ if (cmp == QMessageDataComparator::Equal) {
+ MEmailMailbox* mailbox = NULL;
+ MEmailFolder* parentFolder = NULL;
+ if (fsFolderL(QMessageFolderId(pf->_value.toString()), mailbox, parentFolder)) {
+ CleanupReleasePushL(*mailbox);
+ CleanupReleasePushL(*parentFolder);
+
+ RFolderArray subfolders;
+
+ parentFolder->GetSubfoldersL(subfolders);
+ CleanupClosePushL(subfolders);
+
+ for(TInt i=0; i < subfolders.Count(); i++) {
+ MEmailFolder *subFolder = subfolders[i];
+
+ ids.append(QMessageFolderId(addIdPrefix(
+ QString::number(subFolder->FolderId().iId),
+ SymbianHelpers::EngineTypeFreestyle)));
+
+ subFolder->Release();
+ }
+
+ CleanupStack::PopAndDestroy(&subfolders);
+ CleanupStack::PopAndDestroy(parentFolder);
+ CleanupStack::PopAndDestroy(mailbox);
+ }
+ } else { // NotEqual
+ // TODO:
+ }
+ } else if (pf->_comparatorType == QMessageFolderFilterPrivate::Inclusion) {
+ QMessageDataComparator::InclusionComparator cmp(static_cast<QMessageDataComparator::InclusionComparator>(pf->_comparatorValue));
+ if (cmp == QMessageDataComparator::Includes) {
+ // TODO:
+ } else { // Excludes
+ // TODO:
+ }
+ }
+ break;
+ }
+ case QMessageFolderFilterPrivate::AncestorFolderIds:
+ {
+ if (pf->_comparatorType == QMessageFolderFilterPrivate::Inclusion) {
+ QMessageDataComparator::InclusionComparator cmp(static_cast<QMessageDataComparator::InclusionComparator>(pf->_comparatorValue));
+ if (!pf->_value.isNull()) { // QMessageFolderId
+ if (cmp == QMessageDataComparator::Includes) {
+ // TODO:
+ } else { // Excludes
+ // TODO:
+ }
+ } else { // QMessageFolderFilter
+ if (cmp == QMessageDataComparator::Includes) {
+ // TODO:
+ } else { // Excludes
+ // TODO:
+ }
+ }
+ }
+ break;
+ }
+ case QMessageFolderFilterPrivate::ParentAccountIdFilter:
+ case QMessageFolderFilterPrivate::None:
+ break;
+ }
+ }
+
+ if (!filterHandled) {
+ ids = allFolders();
+ }
+
+ return ids;
+}
+
+
+QMessageFolderIdList CFSEngine::allFolders() const
+{
+ QMessageFolderIdList ids;
+ TRAPD(err, updateEmailAccountsL());
+ Q_UNUSED(err)
+ foreach (QMessageAccount value, m_accounts) {
+ QMessageFolderIdList ids2 = folderIdsByAccountId(value.id());
+ ids << ids2;
+ }
+ return ids;
+}
+
+QMessageFolderIdList CFSEngine::folderIdsByAccountId(const QMessageAccountId& accountId) const
+{
+ QMessageFolderIdList idList;
+ TRAPD(err, idList << folderIdsByAccountIdL(accountId))
+ Q_UNUSED(err);
+ return idList;
+}
+
+QMessageFolderIdList CFSEngine::folderIdsByAccountIdL(const QMessageAccountId& accountId) const
+{
+ QMessageFolderIdList folderIds;
+
+ if (idType(accountId) != EngineTypeFreestyle)
+ return QMessageFolderIdList();
+
+ QMessageAccount messageAccount = account(accountId);
+
+ TMailboxId mailboxId(stripIdPrefix(accountId.toString()).toInt());
+ MEmailMailbox* mailbox = NULL;
+ mailbox = m_clientApi->MailboxL(mailboxId);
+
+ if (mailbox == NULL)
+ return QMessageFolderIdList();
+
+ CleanupReleasePushL(*mailbox);
+
+ RFolderArray folders;
+
+ mailbox->GetFoldersL(folders);
+ CleanupClosePushL(folders);
+
+ for(TInt i=0; i < folders.Count(); i++) {
+ MEmailFolder *mailFolder = folders[i];
+
+ QString fsIdAsString = addIdPrefix(QString::number(mailFolder->FolderId().iId), SymbianHelpers::EngineTypeFreestyle);
+ folderIds.append(QMessageFolderId(fsIdAsString));
+
+ //TODO: Support for subfolders?
+ mailFolder->Release();
+ }
+
+ CleanupStack::PopAndDestroy(&folders);
+ CleanupStack::PopAndDestroy(mailbox);
+
+ return folderIds;
+}
+
+bool CFSEngine::fsFolderL(const QMessageFolderId& id, MEmailMailbox* mailbox, MEmailFolder* folder) const
+{
+ Q_UNUSED(folder);
+ MEmailFolder* fsFolder = NULL;
+ foreach (QMessageAccount account, m_accounts) {
+ TMailboxId mailboxId(stripIdPrefix(account.id().toString()).toInt());
+ mailbox = m_clientApi->MailboxL(mailboxId);
+
+ TFolderId folderId(
+ stripIdPrefix(id.toString()).toInt(),
+ mailboxId);
+
+ TRAPD(err, folder = mailbox->FolderL(folderId));
+ if (err == KErrNone) {
+ CleanupReleasePushL(*fsFolder);
+ return true;
+ }
+ mailbox->Release();
+ }
+ mailbox = NULL;
+ folder = NULL;
+ return false;
+}
+
+
+QMessage CFSEngine::message(const QMessageId& id) const
+{
+ QMessage message = QMessage();
+ TRAPD(err, message = messageL(id));
+ Q_UNUSED(err);
+ return message;
+}
+
+QMessage CFSEngine::messageL(const QMessageId& id) const
+{
+ QMessage message = QMessage();
+ foreach (QMessageAccount account, m_accounts) {
+ TMailboxId mailboxId(stripIdPrefix(account.id().toString()).toInt());
+ MEmailMailbox* mailbox = m_clientApi->MailboxL(mailboxId);
+ CleanupReleasePushL(*mailbox);
+
+ TMessageId messageId(
+ stripIdPrefix(id.toString()).toInt(),
+ 0, //stripIdPrefix(folderId.toString()).toInt(),
+ mailboxId);
+
+ MEmailMessage* fsMessage = NULL;
+
+ TRAPD(err, fsMessage = mailbox->MessageL(messageId));
+ if (err == KErrNone) {
+ CleanupReleasePushL(*fsMessage);
+ message = CreateQMessageL(fsMessage);
+
+ QMessagePrivate* privateMessage = QMessagePrivate::implementation(message);
+ privateMessage->_id = id;
+ privateMessage->_modified = false;
+
+ CleanupStack::PopAndDestroy(fsMessage);
+ CleanupStack::PopAndDestroy(mailbox);
+ return message;
+ }
+ CleanupStack::PopAndDestroy(mailbox);
+ }
+ return message;
+}
+
+bool CFSEngine::sendEmail(QMessage &message)
+{
+ TMailboxId mailboxId(stripIdPrefix(message.parentAccountId().toString()).toInt());
+ MEmailMailbox* mailbox = NULL;
+ TRAPD(mailerr, mailbox = m_clientApi->MailboxL(mailboxId));
+ Q_UNUSED(mailerr);
+
+ MEmailMessage* fsMessage = NULL;
+ TRAPD(err,
+ fsMessage = createFSMessageL(message, mailbox);
+ fsMessage->SaveChangesL();
+ fsMessage->SendL();
+ );
+
+ if (fsMessage)
+ fsMessage->Release();
+ if (mailbox)
+ mailbox->Release();
+
+ if (err != KErrNone)
+ return false;
+ else
+ return true;
+}
+
+QMessage CFSEngine::CreateQMessageL(MEmailMessage* aMessage) const
+{
+ QMessage message;
+ int size = 0;
+ message.setType(QMessage::Email);
+
+ message.setDate(symbianTTimetoQDateTime(aMessage->Date()));
+ message.setReceivedDate(symbianTTimetoQDateTime(aMessage->Date()));
+
+ const TFolderId& folderId = aMessage->ParentFolderId();
+ TMailboxId mailboxId = folderId.iMailboxId;
+ const QMessageAccountId accountId = QMessageAccountId(QString::number(mailboxId.iId));
+ message.setParentAccountId(accountId);
+ QMessagePrivate* privateMessage = QMessagePrivate::implementation(message);
+ privateMessage->_parentFolderId = QMessageFolderId(QString::number(folderId.iId));
+
+ MEmailMailbox* mailbox = m_clientApi->MailboxL(mailboxId);
+ MEmailFolder* folder = mailbox->FolderL(folderId);
+ QMessagePrivate::setStandardFolder(message, QMessage::InboxFolder);
+ if (folder->FolderType() == EDrafts) {
+ QMessagePrivate::setStandardFolder(message, QMessage::DraftsFolder);
+ } else if (folder->FolderType() == EDeleted) {
+ QMessagePrivate::setStandardFolder(message, QMessage::TrashFolder);
+ } else if (folder->FolderType() == ESent) {
+ QMessagePrivate::setStandardFolder(message, QMessage::SentFolder);
+ }
+ folder->Release();
+ mailbox->Release();
+
+ if (aMessage->Flags() & EFlag_Read) {
+ privateMessage->_status = privateMessage->_status | QMessage::Read;
+ }
+
+ if (aMessage->Flags() & EFlag_Important) {
+ message.setPriority(QMessage::HighPriority);
+ } else if (aMessage->Flags() & EFlag_Low) {
+ message.setPriority(QMessage::LowPriority);
+ } else {
+ message.setPriority(QMessage::NormalPriority);
+ }
+
+ // bodytext and attachment(s)
+ MEmailMessageContent* content = aMessage->ContentL();
+ if (content) {
+ AddContentToMessage(content, &message);
+ }
+
+ REmailAttachmentArray attachments;
+ CleanupResetAndRelease<MEmailAttachment>::PushL(attachments);
+ TInt count = aMessage->GetAttachmentsL(attachments);
+ if (count > 0)
+ privateMessage->_status = privateMessage->_status | QMessage::HasAttachments;
+
+ for(TInt i = 0; i < count; i++) {
+ TInt availableSize = attachments[i]->AvailableSize();
+ QByteArray name = QString::fromUtf16(attachments[i]->FileNameL().Ptr(), attachments[i]->FileNameL().Length()).toLocal8Bit();
+ QByteArray mimeType; // TODO: email client api doesn't offer information about attachment mimetype
+ QByteArray mimeSubType; // TODO;
+ int size = attachments[i]->TotalSize();
+ QMessageContentContainer attachment = QMessageContentContainerPrivate::from(
+ aMessage->MessageId().iId,
+ attachments[i]->Id().iId,
+ name, mimeType,
+ mimeSubType, size);
+ addAttachmentToMessage(message, attachment);
+ }
+ CleanupStack::PopAndDestroy();
+ attachments.Close();
+
+ //from
+ TPtrC from = aMessage->SenderAddressL()->Address();
+ if (from.Length() > 0) {
+ message.setFrom(QMessageAddress(QMessageAddress::Email, QString::fromUtf16(from.Ptr(), from.Length())));
+ QMessagePrivate::setSenderName(message, QString::fromUtf16(from.Ptr(), from.Length()));
+ }
+
+ //to
+ REmailAddressArray toRecipients;
+ CleanupResetAndRelease<MEmailAddress>::PushL(toRecipients);
+
+ aMessage->GetRecipientsL(MEmailAddress::ETo, toRecipients);
+ QList<QMessageAddress> toList;
+ for(TInt i = 0; i < toRecipients.Count(); i++) {
+ TPtrC to = toRecipients[i]->Address();
+ toList.append(QMessageAddress(QMessageAddress::Email, QString::fromUtf16(to.Ptr(), to.Length())));
+ }
+ message.setTo(toList);
+ CleanupStack::PopAndDestroy(&toRecipients);
+ toRecipients.Close();
+
+ //cc
+ REmailAddressArray ccRecipients;
+ CleanupResetAndRelease<MEmailAddress>::PushL(ccRecipients);
+ aMessage->GetRecipientsL(MEmailAddress::ECc, ccRecipients);
+ QList<QMessageAddress> ccList;
+ for(TInt i = 0; i < ccRecipients.Count(); i++) {
+ TPtrC cc = ccRecipients[i]->Address();
+ ccList.append(QMessageAddress(QMessageAddress::Email, QString::fromUtf16(cc.Ptr(), cc.Length())));
+ }
+ message.setCc(ccList);
+ CleanupStack::PopAndDestroy(&ccRecipients);
+ ccRecipients.Close();
+
+ //bcc
+ REmailAddressArray bccRecipients;
+ CleanupResetAndRelease<MEmailAddress>::PushL(bccRecipients);
+ aMessage->GetRecipientsL(MEmailAddress::EBcc, bccRecipients);
+ QList<QMessageAddress> bccList;
+ for(TInt i = 0; i < bccRecipients.Count(); i++) {
+ TPtrC bcc = bccRecipients[i]->Address();
+ bccList.append(QMessageAddress(QMessageAddress::Email, QString::fromUtf16(bcc.Ptr(), bcc.Length())));
+ }
+ message.setBcc(bccList);
+ CleanupStack::PopAndDestroy(&bccRecipients);
+ bccRecipients.Close();
+
+ // Read message subject
+ TPtrC subject = aMessage->Subject();
+ if (subject.Length() > 0) {
+ message.setSubject(QString::fromUtf16(subject.Ptr(), subject.Length()));
+ }
+ // TODO: size
+ privateMessage->_size = size;
+
+ return message;
+}
+
+void CFSEngine::AddContentToMessage(MEmailMessageContent* aContent, QMessage* aMessage) const
+{
+ MEmailMultipart* mPart = aContent->AsMultipartOrNull();
+ if (mPart) {
+ TInt partCount = 0;
+ TRAPD(err, partCount = mPart->PartCountL());
+ if (err == KErrNone) {
+ for (TInt i = 0; i < partCount-1; i++) {
+ MEmailMessageContent* content = NULL;
+ TRAPD(err2, content = mPart->PartByIndexL(i));
+ if (err2 == KErrNone) {
+ AddContentToMessage(content, aMessage);
+ content->Release();
+ }
+ }
+ }
+ return;
+ }
+
+ MEmailTextContent* textContent = aContent->AsTextContentOrNull();
+ if (textContent) {
+ TInt availableSize = textContent->AvailableSize();
+ TRAPD(err,
+ TPtrC body = textContent->ContentL();
+ QString text = QString::fromUtf16(body.Ptr(), body.Length());
+ if (textContent->TextType() == MEmailTextContent::EPlainText) {
+ aMessage->setBody(text, "text/plain");
+ }
+ else if (textContent->TextType() == MEmailTextContent::EHtmlText) {
+ aMessage->setBody(text, "text/html");
+ }
+ );
+ Q_UNUSED(err);
+ return;
+ }
+}
+
+void CFSEngine::addAttachmentToMessage(QMessage& message, QMessageContentContainer& attachment) const
+{
+ QMessagePrivate* privateMessage = QMessagePrivate::implementation(message);
+ QMessageContentContainerPrivate* container = QMessagePrivate::containerImplementation(message);
+
+ if (container->_attachments.isEmpty()) {
+ QMessageContentContainerId existingBodyId(message.bodyId());
+ if (existingBodyId == QMessageContentContainerPrivate::bodyContentId()) {
+ // The body content is in the message itself - move it to become the first attachment
+ QMessageContentContainer newBody(message);
+ QMessageContentContainerPrivate::implementation(newBody)->setDerivedMessage(0);
+
+ container->setContentType("multipart", "mixed", "");
+ privateMessage->_bodyId = container->prependContent(newBody);
+ } else {
+ // This message is now multipart
+ container->setContentType("multipart", "mixed", "");
+ }
+
+ container->_available = true;
+ }
+
+ container->appendContent(attachment);
+
+ bool haveAttachments = !container->_attachments.isEmpty();
+ message.setStatus(QMessage::HasAttachments,haveAttachments);
+
+ privateMessage->_modified = true;
+}
+
+QDateTime CFSEngine::symbianTTimetoQDateTime(const TTime& time) const
+{
+ TDateTime dateTime = time.DateTime();
+ QDate qdate = QDate(dateTime.Year(), static_cast<int>(dateTime.Month())+1, dateTime.Day()+1);
+ QTime qtime = QTime(dateTime.Hour(), dateTime.Minute(), dateTime.Second(), dateTime.MicroSecond()/1000 );
+ return QDateTime(qdate, qtime, Qt::UTC);
+}
+
+TTime CFSEngine::qDateTimeToSymbianTTime(const QDateTime& date) const
+{
+ TDateTime dateTime;
+ dateTime.SetYear(date.date().year());
+ dateTime.SetMonth(static_cast<TMonth>(date.date().month()-1));
+ dateTime.SetDay(date.date().day()-1);
+ dateTime.SetHour(date.time().hour());
+ dateTime.SetMinute(date.time().minute());
+ dateTime.SetSecond(date.time().second());
+ dateTime.SetMicroSecond(date.time().msec()*1000);
+ return TTime(dateTime);
+}
+
+TFolderType CFSEngine::standardFolderId(QMessage::StandardFolder standardFolder)
+{
+ switch(standardFolder) {
+ case QMessage::InboxFolder: return EInbox;
+ case QMessage::OutboxFolder: return EOutbox;
+ case QMessage::DraftsFolder: return EDrafts;
+ case QMessage::SentFolder: return ESent;
+ case QMessage::TrashFolder: return EDeleted;
+ default: return EOther;
+ }
+}
+
+CFSMessagesFindOperation::CFSMessagesFindOperation(CFSEngine& aOwner, int aOperationId)
+ : m_owner(aOwner),
+ m_operationId(aOperationId),
+ m_resultCorrectlyOrdered(false),
+ m_receiveNewMessages(false),
+ m_activeSearchCount(0),
+ m_searchField(None)
+{
+ TRAPD(err,
+ m_factory = CEmailInterfaceFactory::NewL();
+ m_interfacePtr = m_factory->InterfaceL(KEmailClientApiInterface);
+ m_clientApi = static_cast<MEmailClientApi*>(m_interfacePtr);
+ );
+ Q_UNUSED(err);
+}
+
+CFSMessagesFindOperation::~CFSMessagesFindOperation()
+{
+ foreach(FSSearchOperation operation, m_searchOperations) {
+ operation.m_search->Release();
+ operation.m_mailbox->Release();
+ }
+
+ m_receiveNewMessages = false;
+ m_clientApi->Release();
+ delete m_factory;
+
+}
+
+void CFSMessagesFindOperation::filterAndOrderMessages(const QMessageFilter &filter, const QMessageSortOrder& sortOrder,
+ QString body, QMessageDataComparator::MatchFlags matchFlags)
+{
+ m_filterList.clear();
+ m_filterList.append(filter);
+ filterAndOrderMessages(m_filterList, sortOrder, body, matchFlags);
+}
+
+void CFSMessagesFindOperation::filterAndOrderMessages(const QMessageFilterPrivate::SortedMessageFilterList& filters,
+ const QMessageSortOrder& sortOrder,
+ QString body,
+ QMessageDataComparator::MatchFlags matchFlags)
+{
+ TRAPD(err, filterAndOrderMessagesL(filters, sortOrder, body, matchFlags));
+ if (err != KErrNone) {
+ //something has failed -> return empty list
+ m_idList = QMessageIdList();
+ QMetaObject::invokeMethod(this, "SearchCompleted", Qt::QueuedConnection);
+ }
+}
+
+void CFSMessagesFindOperation::filterAndOrderMessagesL(const QMessageFilterPrivate::SortedMessageFilterList& filters,
+ const QMessageSortOrder& sortOrder,
+ QString body,
+ QMessageDataComparator::MatchFlags matchFlags)
+{
+ m_numberOfHandledFilters = 0;
+
+ TEmailSortCriteria sortCriteria = TEmailSortCriteria();
+ m_excludeIdList = QMessageIdList();
+
+ m_matchFlags = matchFlags;
+
+ if (filters.count() == 0) {
+ m_idList = QMessageIdList();
+ QMetaObject::invokeMethod(this, "SearchCompleted", Qt::QueuedConnection);
+ return;
+ }
+
+ QMessageFilterPrivate* pf = QMessageFilterPrivate::implementation(filters[m_numberOfHandledFilters]);
+
+ // Set sortOrder
+ if (!sortOrder.isEmpty() ) {
+ QMessageSortOrderPrivate* privateMessageOrdering = QMessageSortOrderPrivate::implementation(sortOrder);
+ QPair<QMessageSortOrderPrivate::Field, Qt::SortOrder> fieldOrder = privateMessageOrdering->_fieldOrderList.at(0);
+ switch (fieldOrder.first) {
+ case QMessageSortOrderPrivate::Type:
+ break;
+ case QMessageSortOrderPrivate::Sender:
+ sortCriteria.iField = TEmailSortCriteria::EBySender;
+ break;
+ case QMessageSortOrderPrivate::Recipients:
+ sortCriteria.iField = TEmailSortCriteria::EByRecipient;
+ break;
+ case QMessageSortOrderPrivate::Subject:
+ sortCriteria.iField = TEmailSortCriteria::EBySubject;
+ break;
+ case QMessageSortOrderPrivate::TimeStamp:
+ sortCriteria.iField = TEmailSortCriteria::EByDate;
+ break;
+ case QMessageSortOrderPrivate::ReceptionTimeStamp:
+ sortCriteria.iField = TEmailSortCriteria::EBySender;
+ break;
+ case QMessageSortOrderPrivate::Read:
+ sortCriteria.iField = TEmailSortCriteria::EByUnread;
+ break;
+ case QMessageSortOrderPrivate::HasAttachments:
+ sortCriteria.iField = TEmailSortCriteria::EByAttachment;
+ break;
+ case QMessageSortOrderPrivate::Incoming:
+ //TODO:
+ break;
+ case QMessageSortOrderPrivate::Removed:
+ //TODO:
+ break;
+ case QMessageSortOrderPrivate::Priority:
+ sortCriteria.iField = TEmailSortCriteria::EByPriority;
+ break;
+ case QMessageSortOrderPrivate::Size:
+ sortCriteria.iField = TEmailSortCriteria::EBySize;
+ break;
+ }
+ sortCriteria.iAscending = fieldOrder.second == Qt::AscendingOrder?true:false;
+ } else {
+ // This is a workaroud for getFolderSpecificMessagesL crashing when default TEmailSortCriteria (EDontCare) is set
+ sortCriteria.iField = TEmailSortCriteria::EByDate;
+ }
+
+ if ((filters.count() == 1) &&
+ (pf->_field == QMessageFilterPrivate::None) &&
+ (pf->_filterList.count() == 0)) {
+ if (pf->_notFilter) {
+ // There is only one filter: empty ~QMessageFilter()
+ // => return empty QMessageIdList
+ m_idList = QMessageIdList();
+ QMetaObject::invokeMethod(this, "SearchCompleted", Qt::QueuedConnection);
+ } else {
+ // There is only one filter: empty QMessageFilter()
+ // => return all messages
+ getAllMessagesL(sortCriteria);
+ }
+ m_numberOfHandledFilters++;
+ return;
+ }
+
+ if (!body.isEmpty()) {
+ m_searchField = Body;
+ m_searchKey = body;
+ }
+
+ switch (pf->_field) {
+
+ case QMessageFilterPrivate::ParentFolderId: {
+ if (idType(pf->_value.toString()) != EngineTypeFreestyle) {
+ QMetaObject::invokeMethod(this, "SearchCompleted", Qt::QueuedConnection);
+ return;
+ }
+ if (pf->_comparatorType == QMessageFilterPrivate::Equality) { // QMessageFolderId
+ QMessageDataComparator::EqualityComparator cmp(static_cast<QMessageDataComparator::EqualityComparator>(pf->_comparatorValue));
+ if (cmp == QMessageDataComparator::Equal) {
+ m_numberOfHandledFilters++;
+ QMessageFolder messageFolder = m_owner.folder(QMessageFolderId(pf->_value.toString()));
+ getFolderSpecificMessagesL(messageFolder, sortCriteria);
+ m_resultCorrectlyOrdered = true;
+ QMetaObject::invokeMethod(this, "SearchCompleted", Qt::QueuedConnection);
+ } else { // NotEqual
+ // TODO:
+ }
+ } else if (pf->_comparatorType == QMessageFilterPrivate::Inclusion) { // QMessageFolderFilter
+ QMessageDataComparator::InclusionComparator cmp(static_cast<QMessageDataComparator::InclusionComparator>(pf->_comparatorValue));
+ if (cmp == QMessageDataComparator::Includes) {
+ // TODO:
+ } else { // Excludes
+ // TODO:
+ }
+ }
+ break;
+ }
+ case QMessageFilterPrivate::Id: {
+ if (idType(pf->_value.toString()) != EngineTypeFreestyle) {
+ QMetaObject::invokeMethod(this, "SearchCompleted", Qt::QueuedConnection);
+ return;
+ }
+ m_numberOfHandledFilters++;
+ if (pf->_comparatorType == QMessageFilterPrivate::Equality) { // QMessageId
+ QMessageDataComparator::EqualityComparator cmp(static_cast<QMessageDataComparator::EqualityComparator>(pf->_comparatorValue));
+ if (!pf->_value.isNull() && pf->_value.toString().length() > QString(SymbianHelpers::freestylePrefix).length()) {
+ if (cmp == QMessageDataComparator::Equal) {
+ QMessage message = m_owner.message(QMessageId(pf->_value.toString()));
+ m_idList.clear();
+ m_idList.append(message.id());
+ m_resultCorrectlyOrdered = true;
+ QMetaObject::invokeMethod(this, "SearchCompleted", Qt::QueuedConnection);
+
+ } else { // NotEqual
+ m_excludeIdList.clear();
+ m_excludeIdList.append(QMessageId(pf->_value.toString()));
+ getAllMessagesL(sortCriteria);
+ }
+ } else {
+ if (cmp == QMessageDataComparator::NotEqual) {
+ getAllMessagesL(sortCriteria);
+ }
+ }
+ } else if (pf->_comparatorType == QMessageFilterPrivate::Inclusion) {
+ QMessageDataComparator::InclusionComparator cmp(static_cast<QMessageDataComparator::InclusionComparator>(pf->_comparatorValue));
+ if (pf->_ids.count() > 0) { // QMessageIdList
+ if (cmp == QMessageDataComparator::Includes) {
+ for (int i=0; i < pf->_ids.count(); i++) {
+ QMessage message = m_owner.message(QMessageId(pf->_ids[i].toString()));
+ m_idList.append(message.id());
+ }
+ QMetaObject::invokeMethod(this, "SearchCompleted", Qt::QueuedConnection);
+ } else { // Excludes
+ for (int i=0; i < pf->_ids.count(); i++) {
+ m_excludeIdList.clear();
+ m_excludeIdList.append(QMessageId(pf->_ids[i].toString()));
+ getAllMessagesL(sortCriteria);
+ }
+ getAllMessagesL(sortCriteria);
+ }
+ } else {
+ //ipEntrySelection = new(ELeave)CMsvEntrySelection;
+ if (cmp == QMessageDataComparator::Excludes) {
+ getAllMessagesL(sortCriteria);
+ }
+ /*// QMessageFilter
+ if (cmp == QMessageDataComparator::Includes) {
+ // TODO:
+ } else { // Excludes
+ // TODO:
+ }*/
+ }
+ }
+ break;
+ }
+ case QMessageFilterPrivate::ParentAccountId: {
+ if (idType(pf->_value.toString()) != EngineTypeFreestyle) {
+ QMetaObject::invokeMethod(this, "SearchCompleted", Qt::QueuedConnection);
+ return;
+ }
+ if (pf->_comparatorType == QMessageFilterPrivate::Equality) { // QMessageAccountId
+ m_numberOfHandledFilters++;
+ QMessageDataComparator::EqualityComparator cmp(static_cast<QMessageDataComparator::EqualityComparator>(pf->_comparatorValue));
+ if (cmp == QMessageDataComparator::Equal) {
+ QMessageAccount messageAccount = m_owner.account(pf->_value.toString());
+ getAccountSpecificMessagesL(messageAccount, sortCriteria);
+ m_resultCorrectlyOrdered = true;
+ } else { // NotEqual
+ QStringList exludedAccounts;
+ exludedAccounts << pf->_value.toString();
+
+ QMessageFilterPrivate* privateFilter = NULL;
+ for (int i=m_numberOfHandledFilters; i < filters.count(); i++) {
+ privateFilter = QMessageFilterPrivate::implementation(filters[i]);
+ if (privateFilter->_field == QMessageFilterPrivate::ParentAccountId &&
+ privateFilter->_comparatorType == QMessageFilterPrivate::Equality) {
+ cmp = static_cast<QMessageDataComparator::EqualityComparator>(privateFilter->_comparatorValue);
+ if (cmp == QMessageDataComparator::NotEqual) {
+ exludedAccounts << privateFilter->_value.toString();
+ m_numberOfHandledFilters++;
+ } else {
+ break;
+ }
+ } else {
+ break;
+ }
+ }
+
+ privateFilter = NULL;
+ if (filters.count() > m_numberOfHandledFilters) {
+ privateFilter = QMessageFilterPrivate::implementation(filters[m_numberOfHandledFilters]);
+ if (privateFilter->_field == QMessageFilterPrivate::StandardFolder &&
+ privateFilter->_comparatorType == QMessageFilterPrivate::Equality) {
+ cmp = static_cast<QMessageDataComparator::EqualityComparator>(privateFilter->_comparatorValue);
+ if (cmp == QMessageDataComparator::Equal) {
+ m_numberOfHandledFilters++;
+ }
+ } else {
+ privateFilter = NULL;
+ }
+ }
+
+ foreach (QMessageAccount value, m_owner.m_accounts) {
+ if (!exludedAccounts.contains(value.id().toString())) {
+ getAccountSpecificMessagesL(value, sortCriteria);
+ }
+ }
+ }
+ }
+ break;
+ }
+
+ case QMessageFilterPrivate::AncestorFolderIds: {
+ m_numberOfHandledFilters++;
+ if (pf->_comparatorType == QMessageFilterPrivate::Inclusion) {
+ QMessageDataComparator::InclusionComparator cmp(static_cast<QMessageDataComparator::InclusionComparator>(pf->_comparatorValue));
+ if (!pf->_value.isNull()) { // QMessageFolderId
+ if (cmp == QMessageDataComparator::Includes) {
+ // TODO:
+ } else { // Excludes
+ // TODO:
+ }
+ } else { // QMessageFolderFilter
+ if (cmp == QMessageDataComparator::Includes) {
+ // TODO:
+ } else { // Excludes
+ // TODO:
+ }
+ }
+ }
+ break;
+ }
+ case QMessageFilterPrivate::Type: {
+ m_numberOfHandledFilters++;
+ QMessageFilterPrivate* privateFilter = NULL;
+ // Check if next filter is StandardFolder filter
+ if (filters.count() > m_numberOfHandledFilters) {
+ privateFilter = QMessageFilterPrivate::implementation(filters[m_numberOfHandledFilters]);
+ if (privateFilter->_field != QMessageFilterPrivate::StandardFolder) {
+ privateFilter = NULL;
+ } else {
+ m_numberOfHandledFilters++;
+ }
+ }
+ if (pf->_comparatorType == QMessageFilterPrivate::Equality) { // QMessage::Type
+ QMessage::Type type = static_cast<QMessage::Type>(pf->_value.toInt());
+ QMessageDataComparator::EqualityComparator cmp(static_cast<QMessageDataComparator::EqualityComparator>(pf->_comparatorValue));
+ if (cmp == QMessageDataComparator::Equal) {
+ QMessageAccountIdList accountIds = m_owner.accountsByType(type);
+ for (int i = 0; i < accountIds.count(); i++) {
+ QMessageAccount messageAccount = m_owner.account(accountIds[i]);
+ getAccountSpecificMessagesL(messageAccount, sortCriteria);
+ }
+ } else { // NotEqual
+ foreach (QMessageAccount value, m_owner.m_accounts) {
+ if (!(value.messageTypes() & type)) {
+ getAccountSpecificMessagesL(value, sortCriteria);
+ }
+ }
+ }
+ } else if (pf->_comparatorType == QMessageFilterPrivate::Inclusion) { // QMessage::TypeFlags
+ QMessage::TypeFlags typeFlags = static_cast<QMessage::TypeFlags>(pf->_value.toInt());
+ QMessageDataComparator::InclusionComparator cmp(static_cast<QMessageDataComparator::InclusionComparator>(pf->_comparatorValue));
+ if (cmp == QMessageDataComparator::Includes) {
+ foreach (QMessageAccount value, m_owner.m_accounts) {
+ if (value.messageTypes() | typeFlags) {
+ getAccountSpecificMessagesL(value, sortCriteria);
+ }
+ }
+
+ } else { // Excludes
+ foreach (QMessageAccount value, m_owner.m_accounts) {
+ if (!(value.messageTypes() & typeFlags)) {
+ getAccountSpecificMessagesL(value, sortCriteria);
+ }
+ }
+ }
+ }
+ break;
+ }
+ case QMessageFilterPrivate::StandardFolder: {
+ m_numberOfHandledFilters++;
+ QMessageDataComparator::EqualityComparator cmp(static_cast<QMessageDataComparator::EqualityComparator>(pf->_comparatorValue));
+ QMessage::StandardFolder standardFolder = static_cast<QMessage::StandardFolder>(pf->_value.toInt());
+ TFolderType stdFolder = m_owner.standardFolderId(standardFolder);
+
+ if (cmp == QMessageDataComparator::Equal) {
+ foreach (QMessageAccount messageAccount, m_owner.m_accounts) {
+ TMailboxId mailboxId(stripIdPrefix(messageAccount.id().toString()).toInt());
+ MEmailMailbox* mailbox = m_clientApi->MailboxL(mailboxId);
+ CleanupReleasePushL(*mailbox);
+ MEmailFolder* folder = mailbox->FolderByTypeL(stdFolder);
+ CleanupReleasePushL(*folder);
+ QMessageFolder standardFolder = m_owner.folder(
+ QMessageFolderId(QString::number(folder->FolderId().iId)));
+ getFolderSpecificMessagesL(standardFolder, sortCriteria);
+ m_activeSearchCount++;
+ CleanupStack::PopAndDestroy(folder);
+ CleanupStack::PopAndDestroy(mailbox);
+ }
+ m_resultCorrectlyOrdered = true;
+ QMetaObject::invokeMethod(this, "SearchCompleted", Qt::QueuedConnection);
+ } else { // NotEqual
+ foreach (QMessageAccount messageAccount, m_owner.m_accounts) {
+ TMailboxId mailboxId(stripIdPrefix(messageAccount.id().toString()).toInt());
+ MEmailMailbox* mailbox = m_clientApi->MailboxL(mailboxId);
+ CleanupReleasePushL(*mailbox);
+ QMessage::StandardFolder i = QMessage::InboxFolder;
+ while (i <= QMessage::TrashFolder) {
+ if (i != standardFolder) {
+ MEmailFolder* folder = mailbox->FolderByTypeL(m_owner.standardFolderId(i));
+ CleanupReleasePushL(*folder);
+ QMessageFolder standardFolder = m_owner.folder(
+ QMessageFolderId(QString::number(folder->FolderId().iId)));
+ getFolderSpecificMessagesL(standardFolder, sortCriteria);
+ CleanupStack::PopAndDestroy(folder);
+ }
+ i = static_cast<QMessage::StandardFolder>(static_cast<int>(i) + 1);
+ }
+ CleanupStack::PopAndDestroy(mailbox);
+ }
+ QMetaObject::invokeMethod(this, "SearchCompleted", Qt::QueuedConnection);
+ }
+ break;
+ }
+
+ case QMessageFilterPrivate::Sender:
+ case QMessageFilterPrivate::Recipients:
+ case QMessageFilterPrivate::Subject:
+ case QMessageFilterPrivate::Status:
+ case QMessageFilterPrivate::Priority:
+ case QMessageFilterPrivate::Size:
+ case QMessageFilterPrivate::ParentAccountIdFilter:
+ case QMessageFilterPrivate::ParentFolderIdFilter:
+ case QMessageFilterPrivate::TimeStamp:
+ case QMessageFilterPrivate::ReceptionTimeStamp:
+ case QMessageFilterPrivate::None:
+ default:
+ break;
+
+ }
+
+ if (body.isEmpty()) {
+ if (m_numberOfHandledFilters < filters.count()) {
+ pf = QMessageFilterPrivate::implementation(filters[m_numberOfHandledFilters]);
+ switch (pf->_field) {
+ case QMessageFilterPrivate::Sender: {
+ m_searchField = Sender;
+ if (pf->_comparatorType == QMessageFilterPrivate::Equality) {
+ QMessageDataComparator::EqualityComparator cmp(static_cast<QMessageDataComparator::EqualityComparator>(pf->_comparatorValue));
+ if (cmp == QMessageDataComparator::Equal) {
+ if (pf->_value.toString().length() > 0) {
+ m_searchKey = pf->_value.toString();
+ m_numberOfHandledFilters++;
+ }
+ } else { // NotEqual
+ // TODO:
+ }
+ } else if (pf->_comparatorType == QMessageFilterPrivate::Inclusion) {
+ QMessageDataComparator::InclusionComparator cmp(static_cast<QMessageDataComparator::InclusionComparator>(pf->_comparatorValue));
+ if (cmp == QMessageDataComparator::Includes) {
+ // TODO:
+ } else { // Excludes
+ // TODO:
+ }
+ }
+ break;
+ }
+
+ case QMessageFilterPrivate::Recipients: {
+ m_searchField = Recipients;
+ if (pf->_comparatorType == QMessageFilterPrivate::Inclusion) {
+ QMessageDataComparator::InclusionComparator cmp(static_cast<QMessageDataComparator::InclusionComparator>(pf->_comparatorValue));
+ if (cmp == QMessageDataComparator::Includes) {
+ if (pf->_value.toString().length() > 0) {
+ m_searchKey = pf->_value.toString();
+ m_numberOfHandledFilters++;
+ }
+ } else { // Excludes
+ //TODO:
+ }
+ }
+ break;
+ }
+
+ case QMessageFilterPrivate::Subject: {
+ m_searchField = Subject;
+ if (pf->_comparatorType == QMessageFilterPrivate::Equality) {
+ QMessageDataComparator::EqualityComparator cmp(static_cast<QMessageDataComparator::EqualityComparator>(pf->_comparatorValue));
+ if (cmp == QMessageDataComparator::Equal) {
+ if (pf->_value.toString().length() > 0) {
+ m_searchKey = pf->_value.toString();
+ m_numberOfHandledFilters++;
+ }
+ } else { // NotEqual
+ // TODO:
+ }
+ } else if (pf->_comparatorType == QMessageFilterPrivate::Inclusion) {
+ QMessageDataComparator::InclusionComparator cmp(static_cast<QMessageDataComparator::InclusionComparator>(pf->_comparatorValue));
+ if (cmp == QMessageDataComparator::Includes) {
+ // TODO:
+ } else { // Excludes
+ // TODO:
+ }
+ }
+ break;
+ }
+ case QMessageFilterPrivate::TimeStamp:
+ case QMessageFilterPrivate::ReceptionTimeStamp:
+ case QMessageFilterPrivate::Status:
+ case QMessageFilterPrivate::Priority:
+ case QMessageFilterPrivate::Size:
+ case QMessageFilterPrivate::ParentAccountIdFilter:
+ case QMessageFilterPrivate::ParentFolderIdFilter:
+ case QMessageFilterPrivate::Id:
+ case QMessageFilterPrivate::ParentFolderId:
+ case QMessageFilterPrivate::AncestorFolderIds:
+ case QMessageFilterPrivate::ParentAccountId:
+ case QMessageFilterPrivate::Type:
+ case QMessageFilterPrivate::StandardFolder:
+ case QMessageFilterPrivate::None:
+ default:
+ break;
+ }
+ if (m_activeSearchCount == 0)
+ getAllMessagesL(sortCriteria);
+ }
+ }
+ if (m_activeSearchCount == 0)
+ QMetaObject::invokeMethod(this, "SearchCompleted", Qt::QueuedConnection);
+}
+
+void CFSMessagesFindOperation::getAllMessagesL(TEmailSortCriteria& sortCriteria)
+{
+ // Get all messages from every known account
+ foreach (QMessageAccount value, m_owner.m_accounts) {
+ getAccountSpecificMessagesL(value, sortCriteria);
+ }
+ if (m_activeSearchCount == 0)
+ QMetaObject::invokeMethod(this, "SearchCompleted", Qt::QueuedConnection);
+}
+
+void CFSMessagesFindOperation::getAccountSpecificMessagesL(QMessageAccount& messageAccount, TEmailSortCriteria& sortCriteria)
+{
+ TMailboxId mailboxId(stripIdPrefix(messageAccount.id().toString()).toInt());
+ FSSearchOperation operation;
+ operation.m_mailbox = m_clientApi->MailboxL(mailboxId);
+ operation.m_search = operation.m_mailbox->MessageSearchL();
+ operation.m_search->AddSearchKeyL(_L("*"));
+ operation.m_search->SetSortCriteriaL( sortCriteria );
+ operation.m_search->StartSearchL( *this ); // this implements MEmailSearchObserver
+ m_activeSearchCount++;
+ m_searchOperations.append(operation);
+}
+
+
+void CFSMessagesFindOperation::getFolderSpecificMessagesL(QMessageFolder& messageFolder, TEmailSortCriteria sortCriteria)
+{
+ m_activeSearchCount++;
+ RSortCriteriaArray sortCriteriaArray;
+ CleanupClosePushL(sortCriteriaArray);
+ TFolderId folderId(stripIdPrefix(messageFolder.id().toString()).toInt(),
+ stripIdPrefix(messageFolder.parentAccountId().toString()).toInt());
+ MEmailMailbox* mailbox = m_clientApi->MailboxL(stripIdPrefix(messageFolder.parentAccountId().toString()).toInt());
+ CleanupReleasePushL(*mailbox);
+ MEmailFolder *mailFolder = mailbox->FolderL(folderId);
+ CleanupReleasePushL(*mailFolder);
+
+ sortCriteriaArray.Append(sortCriteria);
+
+ MMessageIterator* msgIterator = mailFolder->MessagesL(sortCriteriaArray);
+ CleanupReleasePushL(*msgIterator);
+
+ MEmailMessage* msg = NULL;
+ while ( NULL != (msg = msgIterator->NextL())) {
+ QMessageId messageId(addIdPrefix(QString::number(msg->MessageId().iId), SymbianHelpers::EngineTypeFreestyle));
+ if (!m_excludeIdList.contains(messageId)) {
+ m_idList.append(messageId);
+ }
+ msg->Release();
+ }
+
+ CleanupStack::PopAndDestroy(msgIterator);
+ CleanupStack::PopAndDestroy(mailFolder);
+ CleanupStack::PopAndDestroy(mailbox);
+ CleanupStack::PopAndDestroy(&sortCriteriaArray);
+}
+
+void CFSMessagesFindOperation::HandleResultL(MEmailMessage* aMessage)
+{
+ QMessageId messageId(addIdPrefix(QString::number(aMessage->MessageId().iId), SymbianHelpers::EngineTypeFreestyle));
+ if (!m_excludeIdList.contains(messageId)) {
+ m_idList.append(messageId);
+ }
+ aMessage->Release();
+}
+
+void CFSMessagesFindOperation::SearchCompletedL()
+{
+ if (m_receiveNewMessages) {
+ m_receiveNewMessages = false;
+ } else {
+ m_activeSearchCount--;
+ if (m_activeSearchCount <= 0) {
+ QMetaObject::invokeMethod(this, "SearchCompleted", Qt::QueuedConnection);
+ }
+ }
+}
+
+void CFSMessagesFindOperation::SearchCompleted()
+{
+ if (m_searchField != None) {
+ QMessageIdList idList;
+ foreach (QMessageId messageId, m_idList) {
+ if (fillsSearchKeyCriteria(messageId))
+ idList.append(messageId);
+ }
+ m_idList = idList;
+ }
+ m_owner.filterAndOrderMessagesReady(true, m_operationId, m_idList, 1, m_resultCorrectlyOrdered);
+}
+
+bool CFSMessagesFindOperation::fillsSearchKeyCriteria(QMessageId& messageId)
+{
+ QMessage message = m_owner.message(messageId);
+
+ Qt::CaseSensitivity caseSensitivity = (m_matchFlags & QMessageDataComparator::MatchCaseSensitive) ?
+ Qt::CaseSensitive:Qt::CaseInsensitive;
+
+ switch (m_searchField) {
+ case Sender: {
+ return message.from().addressee().contains(m_searchKey, caseSensitivity);
+ }
+ case Recipients: {
+ foreach (QMessageAddress toRecipient, message.to()) {
+ if (toRecipient.addressee().contains(m_searchKey, caseSensitivity))
+ return true;
+ }
+ foreach (QMessageAddress ccRecipient, message.cc()) {
+ if (ccRecipient.addressee().contains(m_searchKey, caseSensitivity))
+ return true;
+ }
+ foreach (QMessageAddress bccRecipient, message.bcc()) {
+ if (bccRecipient.addressee().contains(m_searchKey, caseSensitivity))
+ return true;
+ }
+ return false;
+ }
+ case Subject: {
+ return message.subject().contains(m_searchKey, caseSensitivity);
+ }
+ case Body: {
+ if (message.bodyId() == QMessageContentContainerPrivate::bodyContentId()) {
+ // Message contains only body (not attachments)
+ QString messageBody = message.textContent();
+ return messageBody.contains(m_searchKey, caseSensitivity);
+ } else {
+ // Message contains body and attachments
+ QMessageContentContainerIdList contentIds = message.contentIds();
+ foreach (QMessageContentContainerId id, contentIds){
+ QMessageContentContainer container = message.find(id);
+ QMessageContentContainerPrivate* pPrivateContainer = QMessageContentContainerPrivate::implementation(container);
+ if (pPrivateContainer->_id == message.bodyId()) {
+ // ContentContainer is body
+ return container.textContent().contains(m_searchKey, caseSensitivity);
+ }
+ }
+ }
+ break;
+ }
+ default:
+ break;
+ }
+ return false;
+}
+
+#include "moc_qfsengine_symbian_p.cpp"
+
+QTM_END_NAMESPACE