FCL/sf/app/commonemail: comparison emailuis/nmframeworkadapter/src/nmframeworkadapter.cpp

equal deleted inserted replaced

-:997a02608b3a
+:16ed8d08d0b1
 \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;
 \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);
 	if (mFSfw)
 		{
 	fsFolder = mFSfw->GetFolderByUidL(TFSMailMsgId(mailboxId), TFSMailMsgId(folderId));
 	if (fsFolder)
 	{
 	folder = fsFolder->GetNmFolder();
 	delete fsFolder;
 	fsFolder = NULL;
 const NmId& folderId,
 const NmId& messageId,
 NmMessage*& message)
 {
 NM_FUNCTION;
 TRAPD(err, getMessageByIdL(mailboxId,folderId,messageId,message));
 return err;
 }
 /*!
 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),
 }
 }
 /*!
 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;
 CFSMailBox* currentMailbox = NULL;
 TRAPD (err, currentMailbox = mFSfw->GetMailBoxByUidL(mailboxId));
 if (KErrNone == err) {
 RPointerArray<CFSMailFolder> folders = currentMailbox->ListFolders();
 for (int i = 0; i < folders.Count(); i++) {
 CFSMailFolder *folder,
 QList<NmMessageEnvelope*> &messageEnvelopeList,
 const int maxEnvelopeCount)
 {
 NM_FUNCTION;
 if (!folder || maxEnvelopeCount < 1) {
 return;
 }
 int blockSize = NmListMessagesBlock;
 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::Pop(iterator);
 delete iterator;
 iterator = NULL;
 }
 CleanupStack::PopAndDestroy(); // sorting
 }
 /*!
 Returns list of envelopes from the backend for specific mailbox and folder.
 	const NmId &mailboxId,
 const NmId &folderId,
 QList<NmMessageEnvelope*> &messageEnvelopeList)
 {
 NM_FUNCTION;
 TRAPD(err, listMessagesL(mailboxId,folderId,messageEnvelopeList, NmMaxItemsInMessageList));
 return err;
 }
 const NmId& folderId,
 QList<NmMessageEnvelope*> &messageEnvelopeList,
 const int maxAmountOfEnvelopes)
 {
 NM_FUNCTION;
 TInt err = KErrNone;
 TRAP(err, listMessagesL(mailboxId,folderId, messageEnvelopeList,maxAmountOfEnvelopes) );
 return err;
 }
 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;
 }
 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,
 const NmId &folderId,
 QList<NmMessage*> &messageList,
 const int maxAmountOfMessages)
 {
 NM_FUNCTION;
 TRAPD(err, listMessagesL(mailboxId,folderId,messageList, maxAmountOfMessages));
 return err;
 }
 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)
 if(maxAmountOfEnvelopes < NmListMessagesBlock)
 {
 blockSize = maxAmountOfEnvelopes;
 }
 }
 currentMailbox = mFSfw->GetMailBoxByUidL(mailboxId);
 if (!currentMailbox) {
 User::Leave(KErrNotFound);
 }
 CleanupStack::PushL(currentMailbox);
 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);
 *plainTextPart);
 }
 messageList.append(newMessage);
 }
 }
 CleanupStack::PopAndDestroy( &messages );
 CleanupStack::Pop(iterator);
 delete iterator;
 iterator = NULL;
 }
 */
 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
 /*!
 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) {
 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);
 const NmId &mailboxId,
 const NmId &folderId,
 const NmId &messageId )
 {
 NM_FUNCTION;
 NmOperation *oper = new NmFwaMessageFetchingOperation(mailboxId, folderId, messageId, *mFSfw);
 return oper;
 }
 /*!
 \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;
 }
 \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
 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);
 }
 NmId NmFrameworkAdapter::getStandardFolderId(
 const NmId& mailboxId,
 NmFolderType folderType )
 {
 NM_FUNCTION;
 TFSMailMsgId folderId;
 NmId resultId(0);
 CFSMailBox * currentMailbox(NULL);
 TRAPD(error, currentMailbox = mFSfw->GetMailBoxByUidL(mailboxId) );
 const NmId &folderId,
 const NmId &messageId,
 NmMessagePart &messagePart)
 {
 NM_FUNCTION;
 TRAPD(err, contentToMessagePartL(mailboxId,folderId,messageId,messagePart));
 return err;
 }
 /*!
 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();
 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);
 }
 	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) {
 	const NmId &mailboxId,
 	const NmId &folderId,
 	const QList<const NmMessageEnvelope*> &envelopeList)
 {
 NM_FUNCTION;
 Q_UNUSED(folderId);
 QPointer<NmStoreEnvelopesOperation> operation(NULL);
 RPointerArray<CFSMailMessage> envelopeMessages;
 \return NmMessageCreationOperation
 */
 QPointer<NmMessageCreationOperation> NmFrameworkAdapter::createNewMessage(const NmId &mailboxId)
 {
 NM_FUNCTION;
 QPointer<NmMessageCreationOperation> oper =
 new NmFwaMessageCreationOperation(mailboxId, *mFSfw);
 return oper;
 }
 QPointer<NmMessageCreationOperation> NmFrameworkAdapter::createForwardMessage(
 const NmId &mailboxId,
 const NmId &originalMessageId)
 {
 NM_FUNCTION;
 QPointer<NmMessageCreationOperation> oper =
 new NmFwaForwardMessageCreationOperation(mailboxId, originalMessageId, *mFSfw);
 return oper;
 }
 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));
 TAny* param1,
 TAny* param2,
 TAny* param3)
 {
 NM_FUNCTION;
 switch (aEvent) {
 // Mailbox related events:
 case TFSEventNewMailbox:
 handleMailboxEvent(mailbox, NmMailboxCreated);
 break;
 const NmId& mailboxId,
 const NmId& folderId,
 const NmId& messageId)
 {
 NM_FUNCTION;
 TRAPD(error, removeMessageL(mailboxId, folderId, messageId));
 return error;
 }
 /*!
 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));
 }
 {
 NM_FUNCTION;
 RArray<TFSMailMsgId> messages;
 RArray<TFSMailMsgId> copiedMessages;
 CleanupClosePushL(messages);
 CleanupClosePushL(copiedMessages);
 for (TInt i = 0; i < messageIds.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;
 }
 CleanupStack::PopAndDestroy(2,&messages);
 }
 /*!
 Sends the given message.
 */
 QPointer<NmMessageSendingOperation> NmFrameworkAdapter::sendMessage(
 NmMessage *message)
 {
 NM_FUNCTION;
 QPointer<NmMessageSendingOperation>oper = new NmFwaMessageSendingOperation(*this, message, *mFSfw);
 	return oper;
 }
 /*!
 QPointer<NmAddAttachmentsOperation> NmFrameworkAdapter::addAttachments(
 const NmMessage &message,
 const QList<QString> &fileList)
 {
 NM_FUNCTION;
 QPointer<NmAddAttachmentsOperation>oper = new NmFwaAddAttachmentsOperation(message, fileList, *mFSfw);
 return oper;
 }
 /*!
 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;
 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;
 */
 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;
 void NmFrameworkAdapter::childrenToNmMessagePartL(
 CFSMailMessagePart *cfsParent,
 NmMessagePart *nmParent)
 {
 NM_FUNCTION;
 User::LeaveIfNull(cfsParent);
 User::LeaveIfNull(nmParent);
 RPointerArray<CFSMailMessagePart> parts;
 cfsParent->ChildPartsL(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);
 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);
 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);
 handles mailbox related events
 */
 void NmFrameworkAdapter::handleMailboxEvent( TFSMailMsgId mailbox, NmMailboxEvent event)
 {
 NM_FUNCTION;
 QList<NmId> mailboxIds;
 NmId nmId;
-if (event == NmMailboxDeleted) {
+if (event == NmMailboxDeleted ||
+event == NmMailboxCreated ||
+event == NmMailboxChanged) {
 		nmId = mailbox.GetNmId();
 } else {
 		nmId = getMailboxIdByMailMsgId(mailbox);
 }
 mailboxIds.append(nmId);
 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();
 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();
 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();

changeset 59	16ed8d08d0b1
parent 54	997a02608b3a
child 62	a8c646b56683