--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/emailuis/nmframeworkadapter/src/nmframeworkadapter.cpp Tue Aug 31 15:04:17 2010 +0300
@@ -0,0 +1,1799 @@
+/*
+* Copyright (c) 2009 - 2010 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:
+*
+*/
+
+#include "nmframeworkadapterheaders.h"
+
+/*!
+ \class NmFrameworkAdapter
+
+ \brief The NmFrameworkAdapter works as an adapter between emailframework which is (legacy)
+ Symbian code and emailuis which is done using QT.
+
+ The NmFrameworkAdapter works as an adapter between emailframework which is (legacy)
+ Symbian code and emailuis which is done using QT. Most functions in the adapter merely do d
+ ata type conversions and forward function calls to emailframework implementation.
+ Also events coming from emailframework are converted and emitted as signals.
+ */
+
+static const int NmListMessagesBlock = 100;
+
+
+
+/*!
+ Constructor
+*/
+NmFrameworkAdapter::NmFrameworkAdapter()
+: mFSfw(NULL),
+ mSearchObserver(NULL),
+ mCurrentMailBox(NULL),
+ mStateExtension(NULL)
+{
+ NM_FUNCTION;
+
+ // get s60 email framework
+ TRAP_IGNORE(mFSfw = CFSMailClient::NewL());
+
+ if (mFSfw) {
+ TRAP_IGNORE(mFSfw->AddObserverL(*this));
+ }
+}
+
+/*!
+ Destructor
+*/
+NmFrameworkAdapter::~NmFrameworkAdapter()
+{
+ NM_FUNCTION;
+
+ delete mCurrentMailBox;
+ mCurrentMailBox = NULL;
+
+ mStateExtension = NULL;
+
+ if (mSearchObserver) {
+ delete mSearchObserver;
+ mSearchObserver = NULL;
+ }
+
+ if (mFSfw) {
+ mFSfw->RemoveObserver(*this);
+ mFSfw->Close();
+ }
+
+ mFSfw = NULL;
+}
+
+/*!
+ Add ids of all existing mailboxes to list given as reference.
+
+ \param mailboxIdList The list to receive the mailbox ids.
+
+ \return Error code.
+ */
+int NmFrameworkAdapter::listMailboxIds(QList<NmId>& mailboxIdList)
+{
+ NM_FUNCTION;
+
+ QList<NmMailbox*> mailboxList;
+ int ret = listMailboxes(mailboxList);
+
+ if (ret == NmNoError) {
+ QListIterator<NmMailbox*> iterator(mailboxList);
+ while (iterator.hasNext()) {
+ NmMailbox *box = iterator.next();
+ mailboxIdList.append(box->id());
+ delete box;
+ box = NULL;
+ }
+ }
+ return ret;
+}
+
+/*!
+ Fill array given as reference with new mailbox objects, one for each existing mailbox.
+
+ \param mailboxList The list to receive the mailbox object pointers, ownership of which is transferred to caller.
+
+ \return Error code.
+ */
+int NmFrameworkAdapter::listMailboxes(QList<NmMailbox*>& mailboxList)
+{
+ NM_FUNCTION;
+
+ // get list of mailboxes from all plugins
+ TFSMailMsgId id;
+ id.SetNullId();
+ RPointerArray<CFSMailBox> mailBoxes;
+
+ //if id.IsNullId(), mailboxes are listed from all plugins.
+ //otherwise, only from the given one.
+ TInt rcode = mFSfw->ListMailBoxes(id, mailBoxes);
+
+ if (rcode == NmNoError) {
+ // convert mailbox data to QT classes
+ NmMailbox *box(NULL);
+ for (TInt i(0) ; i < mailBoxes.Count(); i++) {
+ box = NULL;
+ if (mailBoxes[i]) {
+ box = mailBoxes[i]->GetNmMailbox();
+ }
+ if (box) {
+ mailboxList.append(box);
+ }
+ }
+ }
+ mailBoxes.ResetAndDestroy();
+ return rcode;
+}
+
+/*!
+ Get a pointer to a new mailbox object for the mailbox identified by id.
+
+ \param id Id of the mailbox.
+ \param mailbox Pointer reference to receive the mailbox object, ownership of which is transferred to caller.
+
+ \return Error code.
+ */
+int NmFrameworkAdapter::getMailboxById(const NmId& id, NmMailbox*& mailbox)
+{
+ NM_FUNCTION;
+
+ const TFSMailMsgId mailMsgId(id.pluginId32(), id.id32());
+ CFSMailBox *box(NULL);
+ TRAPD(err, box = mFSfw->GetMailBoxByUidL(mailMsgId));
+ if (err == KErrNone && box) {
+ mailbox = box->GetNmMailbox();
+ delete box;
+ box = NULL;
+ }
+ return err;
+}
+
+/*!
+ Deletes the mailbox with the given id asynchronously.
+
+ \param mailboxId Id of the mailbox to be deleted.
+
+ \return Error code.
+ */
+QPointer<NmOperation> NmFrameworkAdapter::deleteMailboxById(const NmId& mailboxId)
+{
+ NM_FUNCTION;
+ QPointer<NmOperation> oper = new NmFwaDeleteMailboxOperation(mailboxId, *mFSfw);
+ return oper;
+}
+
+/*!
+ Returns folder
+
+ \param mailboxId Id of the mailbox containing the folder.
+ \param folderId Id of the requested folder
+ \param message Pointer reference to receive a folder object, ownership is transferred.
+
+ \return Error code.
+ */
+int NmFrameworkAdapter::getFolderById(const NmId& mailboxId, const NmId& folderId, NmFolder*& folder)
+{
+ NM_FUNCTION;
+
+ TRAPD(err, getFolderByIdL(mailboxId, folderId, folder));
+ return err;
+}
+
+/*!
+ Leaving version of getFolderById function
+ */
+void NmFrameworkAdapter::getFolderByIdL(const NmId& mailboxId, const NmId& folderId, NmFolder*& folder)
+{
+ NM_FUNCTION;
+
+ CFSMailFolder* fsFolder(NULL);
+ fsFolder = mFSfw->GetFolderByUidL(TFSMailMsgId(mailboxId), TFSMailMsgId(folderId));
+ if (fsFolder) {
+ folder = fsFolder->GetNmFolder();
+ delete fsFolder;
+ fsFolder = NULL;
+ } else {
+ User::Leave(KErrNotFound);
+ }
+}
+
+
+/*!
+ Returns message from the store together with whole message part structure
+
+ \param mailboxId Id of the mailbox containing the folder.
+ \param folderId Id of the folder containing the message.
+ \param messageId Id of the message.
+ \param message Pointer reference to receive a message object containing requested message,
+ ownership is transferred.
+
+ \return Error code.
+ */
+int NmFrameworkAdapter::getMessageById(
+ const NmId& mailboxId,
+ const NmId& folderId,
+ const NmId& messageId,
+ NmMessage*& message)
+{
+ NM_FUNCTION;
+
+ TRAPD(err, getMessageByIdL(mailboxId, folderId, messageId, message));
+ return err;
+}
+
+/*!
+ Leaving version of getMessageById function
+ */
+void NmFrameworkAdapter::getMessageByIdL(
+ const NmId& mailboxId,
+ const NmId& folderId,
+ const NmId& messageId,
+ NmMessage*& message)
+{
+ NM_FUNCTION;
+
+ // select message details to be listed
+ TFSMailDetails details(EFSMsgDataStructure);
+
+ CFSMailMessage* newMessage(NULL);
+ newMessage = mFSfw->GetMessageByUidL(TFSMailMsgId(mailboxId), TFSMailMsgId(folderId),
+ TFSMailMsgId(messageId), details);
+
+ // GetMessageByUidL can return NULL pointer
+ if (newMessage) {
+ message = newMessage->GetNmMessage();
+ //assign all children found by mail plugin to NmMessage
+
+ message->removeAllChildParts();
+ childrenToNmMessagePartL(newMessage, message);
+ delete newMessage;
+ newMessage = NULL;
+ }
+ else {
+ User::Leave(KErrNotFound);
+ }
+}
+
+/*!
+ Returns list of folders in a mailbox.
+
+ \param mailboxId Id of the mailbox containing the folder.
+ \param folderList Reference to a pointer list to receive pointers to the folders.
+
+ \return Error code.
+ */
+int NmFrameworkAdapter::listFolders(
+ const NmId& mailboxId,
+ QList<NmFolder*>& folderList)
+{
+ NM_FUNCTION;
+ int err(NmNoError);
+ CFSMailBox* currentMailbox(NULL);
+ TRAP(err, currentMailbox = mFSfw->GetMailBoxByUidL(mailboxId));
+ if (KErrNone == err && currentMailbox) {
+ RPointerArray<CFSMailFolder> folders = currentMailbox->ListFolders();
+ for (int i = 0; i < folders.Count(); i++) {
+ folderList.append(folders[i]->GetNmFolder());
+ }
+ delete currentMailbox;
+ currentMailbox = NULL;
+ } else {
+ err = NmNotFoundError;
+ }
+ return err;
+}
+
+
+/*!
+ Fetches all the messages from the given folder and appends their meta data
+ into the given list.
+
+ \param folder The folder instance.
+ \param messageEnvelopeList The list where the data is stored to.
+ \param maxEnvelopeCount The maximum number of messages to get.
+*/
+void NmFrameworkAdapter::getMessagesFromFolderL(
+ CFSMailFolder *folder,
+ QList<NmMessageEnvelope*> &messageEnvelopeList,
+ const int maxEnvelopeCount)
+{
+ NM_FUNCTION;
+ // validity of input parameters is checked in calling function
+ int blockSize = NmListMessagesBlock;
+ int maxItemCount = NmMaxItemsInMessageList;
+
+ if (maxEnvelopeCount < NmMaxItemsInMessageList) {
+ maxItemCount = maxEnvelopeCount;
+
+ if(maxEnvelopeCount < NmListMessagesBlock) {
+ blockSize = maxEnvelopeCount;
+ }
+ }
+
+ // First prepare all the parameters and select message details to be listed.
+ TFSMailDetails details(EFSMsgDataEnvelope);
+
+ // Set the sorting criteria.
+ TFSMailSortCriteria criteria;
+ criteria.iField = EFSMailSortByDate;
+ criteria.iOrder = EFSMailDescending;
+ RArray<TFSMailSortCriteria> sorting;
+ CleanupClosePushL(sorting);
+ sorting.Append(criteria);
+
+ // Get the message list from the backend.
+ MFSMailIterator* iterator(NULL);
+ iterator = folder->ListMessagesL(details, sorting);
+
+ if (iterator) {
+ CleanupStack::PushL(iterator);
+ RPointerArray<CFSMailMessage> messages;
+ CleanupResetAndDestroy<CFSMailMessage>::PushL(messages);
+
+ // The message list is fetched in blocks to prevent OOM in protocol
+ // plugin side.
+ bool moreMessagesToFollow(false);
+ moreMessagesToFollow = iterator->NextL(TFSMailMsgId(), blockSize, messages);
+
+ for (int i = blockSize;
+ i < maxItemCount && moreMessagesToFollow;
+ i += blockSize) {
+ moreMessagesToFollow =
+ iterator->NextL(messages[i-1]->GetMessageId(), blockSize, messages);
+ }
+
+ // Add all the found emails into the result list.
+ const TInt messageCount(messages.Count());
+
+ for (TInt i = 0; i < messageCount; ++i) {
+ NmMessageEnvelope *newEnvelope(NULL);
+ newEnvelope = messages[i]->GetNmMessageEnvelope();
+
+ if (newEnvelope) {
+ messageEnvelopeList.append(newEnvelope);
+ }
+ }
+
+ CleanupStack::PopAndDestroy(&messages);
+ CleanupStack::Pop(iterator);
+ delete iterator;
+ iterator = NULL;
+ }
+
+ CleanupStack::PopAndDestroy(); // sorting
+}
+
+
+/*!
+ Returns list of envelopes from the backend for specific mailbox and folder.
+
+ \param mailboxId Id of the mailbox containing the folder.
+ \param folderId Folder id.
+ \param messageMetaDataList Reference to pointer list to receive the envelope objects,
+ ownership is transferred.
+
+ \return Error code.
+ */
+int NmFrameworkAdapter::listMessages(
+ const NmId &mailboxId,
+ const NmId &folderId,
+ QList<NmMessageEnvelope*> &messageEnvelopeList)
+{
+ NM_FUNCTION;
+
+ TRAPD(err, listMessagesL(mailboxId,folderId,messageEnvelopeList, NmMaxItemsInMessageList));
+ return err;
+}
+
+
+/*!
+ Fetches the meta data for each message in the given mailbox and given
+ folder.
+
+ \param mailboxId The ID of the mailbox of which messages to list.
+ \param folderId The ID of the folder of which messages to list.
+ \param messageEnvelopeList The list where the message data is stored to.
+ Note that the ownership is transferred!
+ \param maxAmountOfEnvelopes The maximum number of messages to list.
+
+ \return If success, KErrNone, an error code otherwise.
+*/
+int NmFrameworkAdapter::listMessages(
+ const NmId& mailboxId,
+ const NmId& folderId,
+ QList<NmMessageEnvelope*> &messageEnvelopeList,
+ const int maxAmountOfEnvelopes)
+{
+ NM_FUNCTION;
+
+ TInt err(KErrNone);
+ TRAP(err, listMessagesL(mailboxId,folderId, messageEnvelopeList,maxAmountOfEnvelopes) );
+ return err;
+}
+
+
+/*!
+ Fetches the meta data for each message in the given mailbox and given
+ folder. Note that this private method can leave.
+*/
+void NmFrameworkAdapter::listMessagesL(
+ const NmId &mailboxId,
+ const NmId &folderId,
+ QList<NmMessageEnvelope*> &messageEnvelopeList,
+ const int maxAmountOfEnvelopes)
+{
+ NM_FUNCTION;
+
+ // If we are requesting 0 or less mails, we can just return.
+ if (maxAmountOfEnvelopes <= 0) {
+ return;
+ }
+
+ CFSMailBox *mailbox(NULL);
+ mailbox = mFSfw->GetMailBoxByUidL(mailboxId);
+
+ if (!mailbox) {
+ User::Leave(KErrNotFound);
+ }
+
+ CleanupStack::PushL(mailbox);
+
+ CFSMailFolder* folder(NULL);
+ folder = mFSfw->GetFolderByUidL(mailbox->GetId(), TFSMailMsgId(folderId));
+
+ if (folder) {
+ CleanupStack::PushL(folder);
+ getMessagesFromFolderL(folder, messageEnvelopeList, maxAmountOfEnvelopes);
+ CleanupStack::PopAndDestroy(folder);
+ }
+
+ CleanupStack::PopAndDestroy(mailbox);
+}
+
+
+/*!
+ Returns list of messages from the backend for specific mailbox and folder.
+
+ \param mailboxId Id of the mailbox containing the folder.
+ \param folderId Folder id.
+ \param messageMetaDataList Reference to pointer list to receive the envelope objects,
+ ownership is transferred.
+
+ \return Error code.
+ */
+int NmFrameworkAdapter::listMessages(
+ const NmId &mailboxId,
+ const NmId &folderId,
+ QList<NmMessage*> &messageList,
+ const int maxAmountOfMessages)
+{
+ NM_FUNCTION;
+
+ TRAPD(err, listMessagesL(mailboxId,folderId,messageList, maxAmountOfMessages));
+ return err;
+}
+
+
+/*!
+ Leaving version of list messages with NmMessageList input
+ */
+void NmFrameworkAdapter::listMessagesL(
+ const NmId &mailboxId,
+ const NmId &folderId,
+ QList<NmMessage*> &messageList,
+ const int maxAmountOfEnvelopes)
+{
+ NM_FUNCTION;
+
+ CFSMailBox* currentMailbox(NULL);
+ CFSMailFolder* folder(NULL);
+
+ //If we are requesting 0 or less mails so we can return
+ if( maxAmountOfEnvelopes <= 0)
+ {
+ return;
+ }
+
+ int blockSize = NmListMessagesBlock;
+ int maxLimit = NmMaxItemsInMessageList;
+
+ if( maxAmountOfEnvelopes < NmMaxItemsInMessageList )
+ {
+ maxLimit = maxAmountOfEnvelopes;
+ if(maxAmountOfEnvelopes < NmListMessagesBlock)
+ {
+ blockSize = maxAmountOfEnvelopes;
+ }
+ }
+
+ currentMailbox = mFSfw->GetMailBoxByUidL(mailboxId);
+ if (!currentMailbox) {
+ User::Leave(KErrNotFound);
+ }
+ CleanupStack::PushL(currentMailbox);
+ folder = mFSfw->GetFolderByUidL(currentMailbox->GetId(), TFSMailMsgId(folderId));
+
+ if (folder) {
+ CleanupStack::PushL(folder);
+ // First prepare all the parameters
+ // select message details to be listed
+ TFSMailDetails details(EFSMsgDataEnvelope);
+
+ // set sorting criteria
+ TFSMailSortCriteria criteria;
+ criteria.iField = EFSMailSortByDate;
+ criteria.iOrder = EFSMailDescending;
+ RArray<TFSMailSortCriteria> sorting;
+ CleanupClosePushL(sorting);
+ sorting.Append(criteria);
+
+ TFSMailMsgId currentMessageId; // first call contains NULL id as begin id
+ // get messages list from the backend
+ MFSMailIterator* iterator(NULL);
+
+ iterator = folder->ListMessagesL(details, sorting);
+ if (iterator) {
+ CleanupStack::PushL(iterator);
+ RPointerArray<CFSMailMessage> messages;
+ CleanupResetAndDestroy<CFSMailMessage>::PushL(messages);
+
+ //Message list is fetched in blocks to prevent OOM in protocol plugin side
+ bool moreMessagesToFollow(false);
+ moreMessagesToFollow = iterator->NextL(
+ TFSMailMsgId(), blockSize, messages);
+ for ( int i = blockSize;
+ i < maxLimit && moreMessagesToFollow ;
+ i += blockSize ) {
+ moreMessagesToFollow = iterator->NextL(
+ messages[i-1]->GetMessageId(), blockSize, messages);
+
+ }
+
+ //Add all found emails to the result list
+ for(TInt i=0; i<messages.Count(); i++) {
+ NmMessage* newMessage(NULL);
+ newMessage = messages[i]->GetNmMessage();
+ if (newMessage) {
+ //Add content of message
+ NmMessagePart *plainTextPart = newMessage->plainTextBodyPart();
+ if (plainTextPart) {
+ contentToMessagePart(mailboxId, folderId, newMessage->envelope().messageId(),
+ *plainTextPart);
+ }
+ messageList.append(newMessage);
+ }
+ }
+
+ CleanupStack::PopAndDestroy( &messages );
+ CleanupStack::Pop(iterator);
+ delete iterator;
+ iterator = NULL;
+ }
+ CleanupStack::PopAndDestroy(); // sorting
+ CleanupStack::PopAndDestroy(folder);
+ }
+ CleanupStack::PopAndDestroy(currentMailbox);
+}
+
+
+/*!
+ Starts an asynchronous search for messages with the given search strings.
+ This is part of the public interface.
+
+ \see NmFrameworkAdapter::searchL().
+
+ \param mailboxId The mailbox to search from.
+ \param searchStrings The strings to search.
+
+ \return A possible error code.
+*/
+int NmFrameworkAdapter::search(const NmId &mailboxId,
+ const QStringList &searchStrings)
+{
+ NM_FUNCTION;
+
+ if (!mSearchObserver) {
+ mSearchObserver = new NmMailboxSearchObserver();
+ }
+
+ // Set connections for forwarding the signals emitted by the search
+ // observer.
+ connect(mSearchObserver, SIGNAL(matchFound(const NmId &, const NmId &)),
+ this, SIGNAL(matchFound(const NmId &, const NmId &)), Qt::UniqueConnection);
+ connect(mSearchObserver, SIGNAL(searchComplete()),
+ this, SIGNAL(searchComplete()), Qt::UniqueConnection);
+
+ TRAPD(err, searchL(mailboxId, QList<NmId>(), searchStrings, *mSearchObserver));
+ return err;
+}
+
+
+/*!
+ Cancels the search if one is ongoing.
+
+ \param mailboxId The ID of the mailbox running the search.
+
+ \return A possible error code.
+*/
+int NmFrameworkAdapter::cancelSearch(const NmId &mailboxId)
+{
+ NM_FUNCTION;
+
+ // Get the mailbox with the given ID.
+ CFSMailBox *mailbox(NULL);
+ TRAPD(err, mailbox = mFSfw->GetMailBoxByUidL(mailboxId));
+
+ if (err == KErrNone && mailbox) {
+ mailbox->CancelSearch();
+ delete mailbox;
+ mailbox = NULL;
+ }
+
+ return err;
+}
+
+/*!
+ Indicates application state information to protocol plugins
+ \param mailboxId Id of active mailbox, 0 if application is closed.
+ \param folderId Id of active folder, 0 if application is closed.
+*/
+void NmFrameworkAdapter::updateActiveFolder(
+ const NmId &mailboxId, const NmId &folderId)
+{
+ TRAP_IGNORE(doUpdateActiveFolderL(mailboxId, folderId));
+}
+
+/*!
+ Removes draft message asynchronously
+ */
+QPointer<NmOperation> NmFrameworkAdapter::removeDraftMessage(NmMessage *message)
+{
+ NM_FUNCTION;
+
+ QPointer<NmOperation> oper = new NmFwaRemoveDraftMessageOperation(*this, message, *mFSfw);
+ return oper;
+}
+
+/*!
+ function to process updateActiveFolder. This method may leave.
+ */
+void NmFrameworkAdapter::doUpdateActiveFolderL(
+ const NmId &mailboxId, const NmId &folderId)
+{
+ if ((mFSfw) && (!mCurrentMailBox || mCurrentMailBox->GetId()!=mailboxId)) {
+ delete mCurrentMailBox;
+ mCurrentMailBox = NULL;
+ mCurrentMailBox = mFSfw->GetMailBoxByUidL(mailboxId);
+ }
+ CEmailExtension *extension = getEMailStateExtensionL();
+ CMailboxStateExtension *stateExtension =
+ static_cast<CMailboxStateExtension*>(extension);
+ if (stateExtension) {
+ stateExtension->NotifyActiveFolderChanged(mailboxId, folderId);
+ }
+}
+
+/*!
+ function to process updateActiveFolder. This method may leave.
+ */
+CEmailExtension* NmFrameworkAdapter::getEMailStateExtensionL()
+{
+ if (!mStateExtension && mCurrentMailBox) {
+ // This extension is owned and deleted by the plugin, so no need to
+ // use release unless the extension will be relocated into extensionbase.
+ mStateExtension = mCurrentMailBox->ExtensionL(KEmailMailboxStateExtensionUid);
+ }
+ return mStateExtension;
+}
+
+/*!
+ Starts an asynchronous search for messages with the given search strings.
+
+ \param mailboxId The mailbox to search from.
+ \param folderIds (not used)
+ \param searchStrings The strings to search.
+ \param searchObserver The observer which gets informed about the progress
+ of the search (match found, search complete etc.)
+*/
+void NmFrameworkAdapter::searchL(const NmId &mailboxId,
+ const QList<NmId> &folderIds,
+ const QStringList &searchStrings,
+ NmMailboxSearchObserver &searchObserver)
+{
+ NM_FUNCTION;
+
+ // CFSMailBox has no support for search using folder IDs.
+ Q_UNUSED(folderIds);
+
+ // Get the mailbox with the given ID.
+ CFSMailBox *mailbox(NULL);
+ mailbox = mFSfw->GetMailBoxByUidL(mailboxId);
+
+ if (mailbox) {
+ CleanupStack::PushL(mailbox);
+ RPointerArray<TDesC> strings;
+ CleanupResetAndDestroy<TDesC>::PushL(strings);
+
+ // Convert the search strings to HBufCs.
+ foreach (QString string, searchStrings) {
+ HBufC *buffer = NmConverter::qstringToHBufCLC(string);
+ strings.AppendL(buffer);
+ CleanupStack::Pop(buffer);
+ }
+
+ // Show results in ascending date/time order.
+ TFSMailSortCriteria sortCriteria;
+ sortCriteria.iField = EFSMailSortByDate;
+ sortCriteria.iOrder = EFSMailAscending;
+
+ // Start the search.
+ mailbox->SearchL(strings, sortCriteria, searchObserver);
+
+ // Clean up.
+ strings.ResetAndDestroy();
+ CleanupStack::Pop(&strings);
+ CleanupStack::PopAndDestroy(mailbox);
+ }
+}
+
+
+/*!
+ Starts a message fetching operation.
+
+ \param mailboxId Id of the mailbox containing the folder.
+ \param folderId Id of the folder containing the message.
+ \param messageId Id of the message to fetch.
+
+ \return An NmOperation object for the operation, ownership is transferred to caller
+ */
+QPointer<NmOperation> NmFrameworkAdapter::fetchMessage(
+ const NmId &mailboxId,
+ const NmId &folderId,
+ const NmId &messageId )
+{
+ NM_FUNCTION;
+
+ NmOperation *oper = new NmFwaMessageFetchingOperation(mailboxId, folderId, messageId, *mFSfw);
+ return oper;
+}
+
+/*!
+ Starts a message part fetching operation.
+
+ \param mailboxId Id of the mailbox containing the folder.
+ \param folderId Id of the folder containing the message.
+ \param messageId Id of message containing the message parts
+ \param messagePartId id of message part
+
+ \return An NmOperation object for the operation, ownership is transferred to caller
+ */
+QPointer<NmOperation> NmFrameworkAdapter::fetchMessagePart(
+ const NmId &mailboxId,
+ const NmId &folderId,
+ const NmId &messageId,
+ const NmId &messagePartId)
+{
+ NM_FUNCTION;
+
+ QPointer<NmOperation> oper = new NmFwaMessagePartFetchingOperation(
+ mailboxId, folderId, messageId, messagePartId, *mFSfw);
+ return oper;
+}
+
+/*!
+ Starts a message parts fetching operation.
+
+ \param mailboxId Id of the mailbox containing the folder.
+ \param folderId Id of the folder containing the message.
+ \param messageId Id of message containing the message parts
+ \param messagePartIds ids of message parts
+
+ \return An NmOperation object for the operation, ownership is transferred to caller
+ */
+QPointer<NmOperation> NmFrameworkAdapter::fetchMessageParts(
+ const NmId &mailboxId,
+ const NmId &folderId,
+ const NmId &messageId,
+ const QList<NmId> &messagePartIds)
+{
+ NM_FUNCTION;
+
+ QPointer<NmOperation> oper = new NmFwaMessagePartsFetchingOperation(
+ mailboxId, folderId, messageId, messagePartIds, *mFSfw);
+ return oper;
+}
+
+/*!
+ Returns sharable file handle to message part content
+
+ \param mailboxId Id of the mailbox containing the folder.
+ \param folderId Id of the folder containing the message.
+ \param messageId Id of message containing the message parts
+ \param messagePartId id of message part
+
+ \return XQSharableFile, sharable file object
+ */
+XQSharableFile NmFrameworkAdapter::messagePartFile(
+ const NmId &mailboxId,
+ const NmId &folderId,
+ const NmId &messageId,
+ const NmId &messagePartId)
+{
+ NM_FUNCTION;
+
+ XQSharableFile retFile;
+ TFSMailDetails details(EFSMsgDataEnvelope);
+ TFSMailMsgId fsMboxId(mailboxId);
+ TFSMailMsgId fsFolderId(folderId);
+ TFSMailMsgId fsMsgId(messageId);
+ TFSMailMsgId fsMsgPartId(messagePartId);
+
+ CFSMailMessage* fsMessage(NULL);
+ int error(KErrNone);
+ TRAP(error, fsMessage = mFSfw->GetMessageByUidL(fsMboxId, fsFolderId,
+ fsMsgId, details) );
+
+ CFSMailMessagePart* fsMessagePart(NULL);
+ if (fsMessage && error == KErrNone) {
+ TRAP(error, fsMessagePart = fsMessage->ChildPartL(fsMsgPartId) );
+
+ }
+ if (fsMessagePart && error == KErrNone) {
+ RFile file = fsMessagePart->GetContentFileL();
+ retFile.setHandle(file);
+ }
+ delete fsMessagePart;
+ fsMessagePart = NULL;
+ delete fsMessage;
+ fsMessage = NULL;
+ return retFile;
+}
+
+/*!
+ Get the id of a standard folder.
+
+ \param mailboxId Id of the mailbox containing the folder.
+ \param folderType Type of standard folder to get the id of.
+
+ \return Id of the standard folder, or NmId for which NmId.getId() == 0 if not found.
+ */
+NmId NmFrameworkAdapter::getStandardFolderId(
+ const NmId& mailboxId,
+ NmFolderType folderType )
+{
+ NM_FUNCTION;
+
+ TFSMailMsgId folderId;
+ NmId resultId(0);
+ CFSMailBox* currentMailbox(NULL);
+
+ TRAPD(error, currentMailbox = mFSfw->GetMailBoxByUidL(mailboxId));
+
+ if(!currentMailbox || error != KErrNone) {
+ return resultId;
+ }
+
+ switch(folderType) {
+ case NmFolderInbox:
+ folderId = currentMailbox->GetStandardFolderId(EFSInbox);
+ break;
+ case NmFolderOutbox:
+ folderId = currentMailbox->GetStandardFolderId(EFSOutbox);
+ break;
+ case NmFolderDrafts:
+ folderId = currentMailbox->GetStandardFolderId(EFSDraftsFolder);
+ break;
+ case NmFolderSent:
+ folderId = currentMailbox->GetStandardFolderId(EFSSentFolder);
+ break;
+ case NmFolderDeleted:
+ folderId = currentMailbox->GetStandardFolderId(EFSDeleted);
+ break;
+ case NmFolderOther:
+ default:
+ folderId = currentMailbox->GetStandardFolderId(EFSOther);
+ break;
+ }
+
+ delete currentMailbox;
+ currentMailbox = NULL;
+
+ resultId.setPluginId32(static_cast<quint32>(folderId.PluginId().iUid));
+ resultId.setId32(folderId.Id());
+
+ return resultId;
+}
+
+/*!
+ Connect to mailbox if not already connected and refresh.
+
+ \param mailboxId Id of the mailbox.
+ \return Async request id or error code.
+ */
+int NmFrameworkAdapter::refreshMailbox(NmId mailboxId)
+{
+ NM_FUNCTION;
+
+ TRAPD(err, RefreshMailboxL(mailboxId)); // return value not used
+ return (err == KErrNone) ? NmNoError : NmGeneralError;
+}
+
+/*!
+ Connect to mailbox if not already connected and refresh.
+
+ \param mailboxId Id of the mailbox.
+ \return Async request id or error code.
+ */
+int NmFrameworkAdapter::goOnline(const NmId& mailboxId)
+{
+ NM_FUNCTION;
+
+ TRAPD(err, GoOnlineL(mailboxId)); // return value not used
+ return (err == KErrNone) ? NmNoError : NmGeneralError;
+}
+
+/*!
+ Disconnect to mailbox if not already disconnected.
+
+ \param mailboxId Id of the mailbox.
+ \return Async request id or error code.
+ */
+int NmFrameworkAdapter::goOffline(const NmId& mailboxId)
+{
+ NM_FUNCTION;
+
+ TRAPD(err, GoOfflineL(mailboxId)); // return value not used
+ return (err == KErrNone) ? NmNoError : NmGeneralError;
+}
+
+/*!
+ Sets content for the given message part. Client shouldn't create
+ message part on its own. Instead it should be requested by calling
+ e.g. getMessageById.
+
+ \param mailboxId Id of the mailbox containing the folder (Unused).
+ \param folderId Id of the folder containing the message (Unused).
+ \param messageId Id of the message (Unused).
+ \param messagePart Part of a message for which content is going to be requested.
+
+ \return Error code.
+ */
+int NmFrameworkAdapter::contentToMessagePart(
+ const NmId &mailboxId,
+ const NmId &folderId,
+ const NmId &messageId,
+ NmMessagePart &messagePart)
+{
+ NM_FUNCTION;
+
+ TRAPD(err, contentToMessagePartL(mailboxId,folderId,messageId,messagePart));
+ return err;
+}
+
+/*!
+ Leaving version of contentToMessagePart function
+ */
+void NmFrameworkAdapter::contentToMessagePartL(
+ const NmId &mailboxId,
+ const NmId &folderId,
+ const NmId &messageId,
+ NmMessagePart &messagePart)
+{
+ NM_FUNCTION;
+
+ CFSMailMessagePart* cfsPart = CFSMailMessagePart::NewLC(messageId,messagePart);
+ cfsPart->SetMailBoxId(TFSMailMsgId(mailboxId));
+ cfsPart->SetFolderId(TFSMailMsgId(folderId));
+ QString contentType = messagePart.contentType();
+
+ if (contentType.startsWith(NmContentTypeTextPlain)) {
+ // add 1 for max size for zero termination and prevend 0 size hbufc
+ HBufC* data = HBufC::NewLC(cfsPart->FetchedContentSize()+1);
+ TPtr dataPtr = data->Des();
+ TInt startOffset = 0;
+
+ cfsPart->GetContentToBufferL(dataPtr, startOffset);
+ messagePart.setTextContent(NmConverter::toQString(dataPtr), contentType);
+ CleanupStack::PopAndDestroy(data);
+ } else {
+ RFile file = cfsPart->GetContentFileL();
+ TInt fileSize = 0;
+ file.Size(fileSize);
+ if (fileSize != 0) {
+ HBufC8* data = HBufC8::NewLC(fileSize);
+ TPtr8 dataPtr = data->Des();
+
+ if (fileSize != 0) {
+ TInt dummyPos = 0;
+ file.Seek(ESeekStart, dummyPos);
+ User::LeaveIfError(file.Read(dataPtr));
+ }
+
+ if (contentType.startsWith(NmContentTypeTextHtml) || contentType.contains( NmContentDescrAttachmentHtml)) {
+ QRegExp rxlen("(?:charset=)(?:\"?)([\\-\\_a-zA-Z0-9]+)", Qt::CaseInsensitive);
+ QString charset;
+ int pos = rxlen.indexIn(contentType);
+ if (pos > -1) {
+ charset = rxlen.cap(1);
+ }
+ QByteArray msgBytes = QByteArray(reinterpret_cast<const char*>(dataPtr.Ptr()), fileSize);
+ QTextCodec *codec = QTextCodec::codecForName(charset.toAscii());
+ if (!codec) {
+ codec = QTextCodec::codecForName("UTF-8");
+ }
+ QString encodedStr = codec->toUnicode(msgBytes);
+ messagePart.setTextContent(encodedStr, contentType);
+ } else {
+ messagePart.setBinaryContent(QByteArray(
+ reinterpret_cast<const char*>(dataPtr.Ptr()), fileSize), contentType);
+ }
+ CleanupStack::PopAndDestroy(data);
+ }
+ file.Close();
+ }
+ CleanupStack::PopAndDestroy(cfsPart);
+}
+
+/*!
+ Deletes the listed messages from specific mailbox and folder.
+
+ \param mailboxId Id of the mailbox containing the folder.
+ \param folderId Id of the folder containing the messages.
+ \param messageIdList List of ids of the messages to be deleted.
+
+ \return Error code.
+ */
+int NmFrameworkAdapter::deleteMessages(
+ const NmId &mailboxId,
+ const NmId &folderId,
+ const QList<NmId> &messageIdList)
+{
+ NM_FUNCTION;
+
+ TInt err(NmNoError);
+ RArray<TFSMailMsgId> messageIds;
+ for (TInt i(0); i < messageIdList.size(); i++) {
+ err = messageIds.Append(TFSMailMsgId(messageIdList[i]));
+ if (err != NmNoError) {
+ break;
+ }
+ }
+ if (NmNoError == err) {
+ TRAP(err, mFSfw->DeleteMessagesByUidL(TFSMailMsgId(mailboxId), TFSMailMsgId(folderId), messageIds));
+ }
+ messageIds.Close();
+
+ return (err == NmNoError) ? NmNoError : NmGeneralError;
+}
+
+/*!
+ Starts an async operation to store listed message envelopes to the given mailbox
+
+ \param mailboxId Id of the mailbox.
+ \param folderId Unused.
+ \param envelopeList List of the envelope objects to store.
+
+ \return NmStoreEnvelopesOperation
+ */
+QPointer<NmStoreEnvelopesOperation> NmFrameworkAdapter::storeEnvelopes(
+ const NmId &mailboxId,
+ const NmId &folderId,
+ const QList<const NmMessageEnvelope*> &envelopeList)
+{
+ NM_FUNCTION;
+
+ Q_UNUSED(folderId);
+
+ QPointer<NmStoreEnvelopesOperation> operation(NULL);
+ RPointerArray<CFSMailMessage> envelopeMessages;
+
+ int count(envelopeList.count());
+ for(int i(0); i < count; i++) {
+ TRAP_IGNORE(envelopeMessages.AppendL(mailMessageFromEnvelopeL(*envelopeList.at(i))));
+ }
+
+ if (envelopeMessages.Count()) {
+ operation = new NmFwaStoreEnvelopesOperation(
+ mailboxId,
+ envelopeMessages,
+ *mFSfw);
+ }
+
+ return operation;
+}
+
+/*!
+ Creates a new message into the drafts folder a mailbox.
+
+ \param mailboxId Id of the mailbox.
+
+ \return NmMessageCreationOperation
+ */
+QPointer<NmMessageCreationOperation> NmFrameworkAdapter::createNewMessage(const NmId &mailboxId)
+{
+ NM_FUNCTION;
+
+ QPointer<NmMessageCreationOperation> oper =
+ new NmFwaMessageCreationOperation(mailboxId, *mFSfw);
+ return oper;
+}
+
+/*!
+ Creates a new forward message into the drafts folder of a mailbox.
+
+ \param mailboxId Id of the mailbox.
+ \param originalMessageId Id of the original message. Original message must be in the given mailbox.
+
+ \return NmMessageCreationOperation
+ */
+QPointer<NmMessageCreationOperation> NmFrameworkAdapter::createForwardMessage(
+ const NmId &mailboxId,
+ const NmId &originalMessageId)
+{
+ NM_FUNCTION;
+
+ QPointer<NmMessageCreationOperation> oper =
+ new NmFwaForwardMessageCreationOperation(mailboxId, originalMessageId, *mFSfw);
+ return oper;
+}
+
+/*!
+ Creates a new reply message into the drafts folder of a mailbox.
+
+ \param mailboxId Id of the mailbox.
+ \param originalMessageId Id of the original message. Original message must be in the given mailbox.
+ \param replyAll Is reply for all recipients?
+
+ \return NmMessageCreationOperation
+ */
+QPointer<NmMessageCreationOperation> NmFrameworkAdapter::createReplyMessage(
+ const NmId &mailboxId,
+ const NmId &originalMessageId,
+ const bool replyAll)
+{
+ NM_FUNCTION;
+
+ QPointer<NmMessageCreationOperation> oper =
+ new NmFwaReplyMessageCreationOperation(mailboxId, originalMessageId, replyAll, *mFSfw);
+ return oper;
+}
+
+/*!
+ Not implemented yet.
+ */
+int NmFrameworkAdapter::saveMessage(const NmMessage &message)
+{
+ NM_FUNCTION;
+
+ Q_UNUSED(message);
+ return NmNoError;
+}
+
+/*!
+ Store asynchronously message with its parts.
+ */
+QPointer<NmOperation> NmFrameworkAdapter::saveMessageWithSubparts(const NmMessage &message)
+{
+ NM_FUNCTION;
+
+ CFSMailMessage * cfsMessage = NULL;
+ QPointer<NmOperation> oper(NULL);
+
+ int err = KErrNone;
+ TRAP(err, cfsMessage = CFSMailMessage::NewL(message));
+ if (err == KErrNone) {
+ //transfers ownership of cfsMessage
+ oper = new NmFwaStoreMessageOperation(cfsMessage, *mFSfw);
+ }
+
+ return oper;
+}
+
+/*!
+ From MFSMailEventObserver
+
+ \sa MFSMailEventObserver
+ */
+void NmFrameworkAdapter::EventL(
+ TFSMailEvent aEvent,
+ TFSMailMsgId mailbox,
+ TAny* param1,
+ TAny* param2,
+ TAny* param3)
+{
+ NM_FUNCTION;
+
+ switch (aEvent) {
+ // Mailbox related events:
+ case TFSEventNewMailbox:
+ handleMailboxEvent(mailbox, NmMailboxCreated);
+ break;
+ case TFSEventMailboxDeleted:
+ handleMailboxEvent(mailbox, NmMailboxDeleted);
+ break;
+ case TFSEventMailboxRenamed:
+ handleMailboxEvent(mailbox, NmMailboxChanged);
+ break;
+
+ //
+ // Mail related events:
+ // signal:
+ // void messageEvent(
+ // NmMessageEvent event,
+ // const NmId &folderId,
+ // QList<NmId> &messageIds
+ // const NmId& mailboxId);
+ //
+ // enum NmMessageEvent
+ // NmMessageCreated,
+ // NmMessageChanged,
+ // NmMessageDeleted
+ //
+
+ // New mails created
+ // param1: RArray<TFSMailMsgId>* aNewEntries
+ // param2: TFSMailMsgId* aParentFolder
+ // param3: NULL
+ case TFSEventNewMail:
+ handleMessageEvent(param1, param2, NmMessageCreated, mailbox);
+ break;
+ // Mails changed
+ // param1: RArray<TFSMailMsgId>* aEntries
+ // param2: TFSMailMsgId* aParentFolder
+ // param3: NULL
+ case TFSEventMailChanged:
+ handleMessageEvent(param1, param2, NmMessageChanged, mailbox);
+ break;
+ // Mails deleted
+ // param1: RArray<TFSMailMsgId>* aEntries
+ // param2: TFSMailMsgId* aParentFolder
+ // param3: NULL
+ case TFSEventMailDeleted:
+ handleMessageEvent(param1, param2, NmMessageDeleted, mailbox);
+ break;
+
+
+ // Mails moved
+ // param1: RArray<TFSMailMsgId>* aEntries
+ // param2: TFSMailMsgId* aNewParentFolder
+ // param3: TFSMailMsgId* aOldParentFolder
+ case TFSEventMailMoved:
+ handleMailMoved(param1, param2, param3, mailbox);
+ break;
+
+ // Mails copied
+ // param1: RArray<TFSMailMsgId>* aNewEntries
+ // param2: TFSMailMsgId* aNewParentFolder
+ // param3: TFSMailMsgId* aOldParentFolder
+ case TFSEventMailCopied:
+ handleMailCopied(param1, param2, mailbox);
+ break;
+
+
+ //sync state related events
+ case TFSEventMailboxSyncStateChanged:
+ handleSyncstateEvent(param1, mailbox);
+ break;
+
+ case TFSEventMailboxOnline:{
+ NmId id = NmConverter::mailMsgIdToNmId(mailbox);
+ emit connectionEvent(Connected, id, NmNoError);
+ }
+ break;
+
+ // param1: errorcode
+ case TFSEventMailboxOffline: {
+ NmId id = NmConverter::mailMsgIdToNmId(mailbox);
+ TInt error(KErrNone);
+ // if param1 is set, and it is != KErrNone, an unexpected offline event has occurred
+ if(param1) {
+ error=*(static_cast<TInt*>(param1));
+ }
+ if(error) {
+ emit connectionEvent(Disconnected, id, NmConnectionError);
+ }
+ else {
+ emit connectionEvent(Disconnected, id, NmNoError);
+ }
+ }
+ break;
+
+ default:
+ break;
+ }
+}
+
+/*!
+ Delete the message from specific mailbox and folder.
+
+ \param mailboxId Id of the mailbox containing the folder.
+ \param folderId Id of the folder containing the message.
+ \param messageId Id of the message.
+
+ \return Error code.
+ */
+int NmFrameworkAdapter::removeMessage(
+ const NmId& mailboxId,
+ const NmId& folderId,
+ const NmId& messageId)
+{
+ NM_FUNCTION;
+
+ TRAPD(error, removeMessageL(mailboxId, folderId, messageId));
+ return error;
+}
+
+/*!
+ Copy messages between folders from specific mailbox.
+
+ \param mailboxId Id of the mailbox containing messages.
+ \param messageIds The list of source message Ids.
+ \param newMessages The list of destination message Ids.
+ \param sourceFolderId Id of source folder.
+ \param destinationFolderId Id of destination folder.
+ */
+int NmFrameworkAdapter::copyMessages(
+ const NmId &mailboxId,
+ const QList<quint64>& messageIds,
+ const NmId& sourceFolderId,
+ const NmId& destinationFolderId)
+{
+ NM_FUNCTION;
+ TRAPD(error, copyMessagesL(mailboxId, messageIds, sourceFolderId, destinationFolderId));
+ return error;
+}
+
+/*!
+ Gets the signature for the given mailbox.
+
+ \param mailboxId Id of the mailbox.
+*/
+int NmFrameworkAdapter::getSignature(const NmId &mailboxId, QString *&signature)
+{
+ NM_FUNCTION;
+ TRAPD(error, getSignatureL(mailboxId, signature));
+
+ return error;
+}
+
+/*!
+ Subscribe to events from a mailbox.
+
+ \param mailboxId Id of the mailbox.
+*/
+void NmFrameworkAdapter::subscribeMailboxEvents(const NmId& mailboxId)
+{
+ NM_FUNCTION;
+
+ TRAP_IGNORE(mFSfw->SubscribeMailboxEventsL(mailboxId, *this));
+}
+
+/*!
+ Unsubscribe to events from a mailbox.
+
+ \param mailboxId Id of the mailbox.
+*/
+void NmFrameworkAdapter::unsubscribeMailboxEvents(const NmId& mailboxId)
+{
+ NM_FUNCTION;
+
+ mFSfw->UnsubscribeMailboxEvents(mailboxId, *this);
+}
+
+
+/*!
+ Leaving version of removeMessage
+*/
+void NmFrameworkAdapter::removeMessageL(
+ const NmId& mailboxId,
+ const NmId& folderId,
+ const NmId& messageId)
+{
+ NM_FUNCTION;
+
+ CFSMailFolder* folder = mFSfw->GetFolderByUidL( TFSMailMsgId(mailboxId), TFSMailMsgId(folderId));
+ CleanupStack::PushL(folder);
+ if ( folder ) {
+ folder->RemoveMessageL(TFSMailMsgId(messageId));
+ }
+ CleanupStack::PopAndDestroy(folder);
+}
+
+/*!
+ Leaving version of copyMessages
+*/
+void NmFrameworkAdapter::copyMessagesL(
+ const NmId &mailboxId,
+ const QList<quint64>& messageIds,
+ const NmId& sourceFolderId,
+ const NmId& destinationFolderId)
+{
+ NM_FUNCTION;
+ TInt count(messageIds.count());
+ if (!count) {
+ return;
+ }
+ RArray<TFSMailMsgId> messages;
+ RArray<TFSMailMsgId> copiedMessages;
+
+ CleanupClosePushL(messages);
+ CleanupClosePushL(copiedMessages);
+
+ for (TInt i = 0; i < count; i++) {
+ NmId tmpId(messageIds[i]);
+ messages.AppendL(TFSMailMsgId(tmpId));
+ }
+
+ CFSMailBox* mailBox(NULL);
+ mailBox = mFSfw->GetMailBoxByUidL(mailboxId);
+ if (mailBox) {
+ mailBox->CopyMessagesL(messages, copiedMessages,
+ TFSMailMsgId(sourceFolderId),
+ TFSMailMsgId(destinationFolderId));
+ delete mailBox;
+ mailBox = NULL;
+ } else {
+ User::Leave(NmNotFoundError);
+ }
+ CleanupStack::PopAndDestroy(2,&messages);
+}
+
+/*!
+ Leaving version of getSignature
+*/
+void NmFrameworkAdapter::getSignatureL(const NmId &mailboxId, QString *&signature)
+{
+ NM_FUNCTION;
+
+ HBufC *sig = mFSfw->GetSignatureL(TFSMailMsgId(mailboxId));
+
+ if (sig) {
+ signature = new QString(NmConverter::toQString(*sig));
+ }
+}
+
+
+/*!
+ Sends the given message.
+ */
+QPointer<NmMessageSendingOperation> NmFrameworkAdapter::sendMessage(
+ NmMessage *message)
+{
+ NM_FUNCTION;
+
+ QPointer<NmMessageSendingOperation>oper = new NmFwaMessageSendingOperation(*this, message, *mFSfw);
+ return oper;
+}
+
+/*!
+ Add attachment into the given message.
+ */
+QPointer<NmAddAttachmentsOperation> NmFrameworkAdapter::addAttachments(
+ const NmMessage &message,
+ const QList<QString> &fileList)
+{
+ NM_FUNCTION;
+
+ QPointer<NmAddAttachmentsOperation>oper = new NmFwaAddAttachmentsOperation(message, fileList, *mFSfw);
+ return oper;
+}
+
+/*!
+ Remove attachment from the given message.
+ */
+QPointer<NmOperation> NmFrameworkAdapter::removeAttachment(
+ const NmMessage &message,
+ const NmId &attachmentPartId)
+{
+ NM_FUNCTION;
+
+ QPointer<NmOperation> oper = new NmFwaRemoveAttachmentOperation(message, attachmentPartId, *mFSfw);
+ return oper;
+}
+
+/*!
+ Returns the current sync state of the given mailbox
+ */
+NmSyncState NmFrameworkAdapter::syncState(const NmId& mailboxId) const
+{
+ NM_FUNCTION;
+
+ CFSMailBox* mailBox = NULL;
+ TRAPD(err, mailBox = mFSfw->GetMailBoxByUidL(TFSMailMsgId(mailboxId)) );
+ if (KErrNone == err && mailBox) {
+ TSSMailSyncState syncState = mailBox->CurrentSyncState();
+ delete mailBox;
+ mailBox = NULL;
+ if (EmailSyncing == syncState) {
+ return Synchronizing;
+ }
+ else {
+ return SyncComplete;
+ }
+ }
+ else {
+ return SyncComplete;
+ }
+}
+
+/*!
+ Returns the current connection state of the given mailbox
+ */
+NmConnectState NmFrameworkAdapter::connectionState(const NmId& mailboxId) const
+{
+ NM_FUNCTION;
+
+ CFSMailBox* mailBox(NULL);
+ TRAPD(err, mailBox = mFSfw->GetMailBoxByUidL(TFSMailMsgId(mailboxId)) );
+ if (KErrNone == err && mailBox) {
+ TFSMailBoxStatus status = mailBox->GetMailBoxStatus();
+ delete mailBox;
+ mailBox = NULL;
+ if (status == EFSMailBoxOnline) {
+ return Connected;
+ }
+ else {
+ return Disconnected;
+ }
+ }
+ else {
+ return Disconnected;
+ }
+}
+
+/*!
+ creates CFSMailMessage based on envelope
+ Call to this must be trapped
+ */
+CFSMailMessage* NmFrameworkAdapter::mailMessageFromEnvelopeL(
+ const NmMessageEnvelope& envelope)
+{
+ NM_FUNCTION;
+
+ NmMessage* nmMessage = new(ELeave) NmMessage( envelope );
+ CFSMailMessage* message = CFSMailMessage::NewL( *nmMessage );
+ delete nmMessage;
+ nmMessage = NULL;
+ return message;
+}
+
+
+/*!
+ Assigns recursively all children to NmMessagePart object.
+ */
+void NmFrameworkAdapter::childrenToNmMessagePartL(
+ CFSMailMessagePart *cfsParent,
+ NmMessagePart *nmParent)
+{
+ NM_FUNCTION;
+
+ User::LeaveIfNull(cfsParent);
+ User::LeaveIfNull(nmParent);
+
+ RPointerArray<CFSMailMessagePart> parts;
+ cfsParent->ChildPartsL(parts);
+ CleanupResetAndDestroy<CFSMailMessagePart>::PushL(parts);
+
+ NmMessagePart *nmPart = NULL;
+ if(parts.Count()){
+ for(int i=0; i<parts.Count(); i++){
+ nmPart = parts[i]->GetNmMessagePart();
+ nmParent->addChildPart(nmPart);
+ childrenToNmMessagePartL(parts[i], nmPart);
+ }
+ }
+ CleanupStack::PopAndDestroy(1, &parts);
+}
+
+/*!
+ Leaving Refresh function
+ */
+int NmFrameworkAdapter::RefreshMailboxL(NmId mailboxId)
+{
+ NM_FUNCTION;
+
+ int result(KErrNotFound);
+ CFSMailBox *currentMailbox(NULL);
+ currentMailbox = mFSfw->GetMailBoxByUidL(mailboxId);
+ if(currentMailbox) {
+ CleanupStack::PushL(currentMailbox);
+ result = currentMailbox->RefreshNowL();
+ CleanupStack::PopAndDestroy(currentMailbox);
+ }
+ return result;
+}
+
+/*!
+ Leaving Go Online function
+ */
+int NmFrameworkAdapter::GoOnlineL(const NmId& mailboxId)
+{
+ NM_FUNCTION;
+
+ int result(KErrNotFound);
+ CFSMailBox *currentMailbox(NULL);
+ currentMailbox = mFSfw->GetMailBoxByUidL(mailboxId);
+ if(currentMailbox) {
+ CleanupStack::PushL(currentMailbox);
+ currentMailbox->GoOnlineL();
+ CleanupStack::PopAndDestroy(currentMailbox);
+ }
+ return result;
+}
+
+/*!
+ Leaving Go Offline function
+ */
+int NmFrameworkAdapter::GoOfflineL(const NmId& mailboxId)
+{
+ NM_FUNCTION;
+
+ int result(KErrNotFound);
+ CFSMailBox *currentMailbox(NULL);
+ currentMailbox = mFSfw->GetMailBoxByUidL(mailboxId);
+ if(currentMailbox) {
+ CleanupStack::PushL(currentMailbox);
+ currentMailbox->GoOfflineL();
+ CleanupStack::PopAndDestroy(currentMailbox);
+ }
+ return result;
+}
+
+/*!
+ handles mailbox related events
+ */
+void NmFrameworkAdapter::handleMailboxEvent(TFSMailMsgId mailbox, NmMailboxEvent event)
+{
+ NM_FUNCTION;
+
+ QList<NmId> mailboxIds;
+ NmId nmId = mailbox.GetNmId();
+ mailboxIds.append(nmId);
+ emit mailboxEvent(event, mailboxIds);
+ }
+
+/*!
+ handles new, changed, deleted events
+ */
+void NmFrameworkAdapter::handleMessageEvent(
+ TAny* param1,
+ TAny* param2,
+ NmMessageEvent event,
+ TFSMailMsgId mailbox)
+{
+ NM_FUNCTION;
+
+ NmId nmMsgId(0);
+ QList<NmId> messageIds;
+ RArray<TFSMailMsgId>* newFsEntries = reinterpret_cast<RArray<TFSMailMsgId>*> (param1);
+ TFSMailMsgId* fsFolderId = reinterpret_cast<TFSMailMsgId*> (param2);
+ NmId folderId = fsFolderId->GetNmId();
+
+ TFSMailMsgId fsMsgId;
+ for(TInt i = 0; i < newFsEntries->Count(); i++){
+ fsMsgId = (*newFsEntries)[i];
+ nmMsgId = fsMsgId.GetNmId();
+ messageIds.append(nmMsgId);
+ }
+ emit messageEvent(event, folderId, messageIds, mailbox.GetNmId());
+}
+
+/*!
+ function to handle mailmoved event
+ */
+void NmFrameworkAdapter::handleMailMoved(TAny* param1,TAny* param2,TAny* param3, TFSMailMsgId mailbox)
+{
+ NM_FUNCTION;
+
+ NmId nmMsgId(0);
+ QList<NmId> messageIds;
+ RArray<TFSMailMsgId>* newFsEntries = reinterpret_cast<RArray<TFSMailMsgId>*> (param1);
+ TFSMailMsgId* fsFromFolderId = reinterpret_cast<TFSMailMsgId*> (param3);
+ NmId fromFolderId = fsFromFolderId->GetNmId();
+ TFSMailMsgId* fsToFolderId = reinterpret_cast<TFSMailMsgId*> (param2);
+ NmId toFolderId = fsToFolderId->GetNmId();
+
+ TFSMailMsgId fsMsgId;
+ for(TInt i = 0; i < newFsEntries->Count(); i++){
+ fsMsgId = (*newFsEntries)[i];
+ nmMsgId = fsMsgId.GetNmId();
+ messageIds.append(nmMsgId);
+ }
+ // Yes, this is supposed to emit two signals from single incoming
+ // event. Design decison was to create separate signals.
+ emit messageEvent(NmMessageDeleted, fromFolderId, messageIds, mailbox.GetNmId());
+ emit messageEvent(NmMessageCreated, toFolderId, messageIds, mailbox.GetNmId());
+}
+
+/*!
+ function to handle mailcopied event
+ */
+void NmFrameworkAdapter::handleMailCopied(TAny* param1,TAny* param2, TFSMailMsgId mailbox)
+{
+ NM_FUNCTION;
+
+ NmId nmMsgId(0);
+ QList<NmId> messageIds;
+ RArray<TFSMailMsgId>* newFsEntries = reinterpret_cast<RArray<TFSMailMsgId>*> (param1);
+ TFSMailMsgId* fsToFolderId = reinterpret_cast<TFSMailMsgId*> (param2);
+ NmId toFolderId = fsToFolderId->GetNmId();
+
+ TFSMailMsgId fsMsgId;
+ for(TInt i = 0; i < newFsEntries->Count(); i++){
+ fsMsgId = (*newFsEntries)[i];
+ nmMsgId = fsMsgId.GetNmId();
+ messageIds.append(nmMsgId);
+ }
+ // Not interested in param3 (aOldParentFolder)
+ emit messageEvent(NmMessageCreated, toFolderId, messageIds, mailbox.GetNmId());
+}
+
+void NmFrameworkAdapter::handleSyncstateEvent(TAny* param1, TFSMailMsgId mailbox)
+{
+ NM_FUNCTION;
+
+ TSSMailSyncState* state = static_cast<TSSMailSyncState*>( param1 );
+ NmOperationCompletionEvent event;
+ event.mMailboxId = NmConverter::mailMsgIdToNmId(mailbox);
+ event.mOperationType = Synch;
+
+ switch(*state)
+ {
+ case StartingSync:
+ {
+ event.mCompletionCode = NmNoError;
+ emit syncStateEvent(Synchronizing, event);
+ break;
+ }
+ case FinishedSuccessfully:
+ {
+ event.mCompletionCode = NmNoError;
+ emit syncStateEvent(SyncComplete, event);
+ break;
+ }
+ case PasswordNotVerified:
+ {
+ event.mCompletionCode = NmAuthenticationError;
+ emit syncStateEvent(SyncComplete, event);
+ break;
+ }
+ case SyncCancelled:
+ {
+ event.mCompletionCode = NmCancelError;
+ emit syncStateEvent(SyncComplete, event);
+ break;
+ }
+ case ServerConnectionError:
+ {
+ event.mCompletionCode = NmServerConnectionError;
+ emit syncStateEvent(SyncComplete, event);
+ break;
+ }
+ case SyncError:
+ {
+ event.mCompletionCode = NmConnectionError;
+ emit syncStateEvent(SyncComplete, event);
+ break;
+ }
+ default:
+ // ignore other statuses
+ break;
+ };
+}
+Q_EXPORT_PLUGIN(NmFrameworkAdapter)
+