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

equal deleted inserted replaced

-:16ed8d08d0b1
+:478bc57ad291
 NM_FUNCTION;
 QList<NmMailbox*> mailboxList;
 int ret = listMailboxes(mailboxList);
-if ( ret == NmNoError ) {
+if (ret == NmNoError) {
 QListIterator<NmMailbox*> iterator(mailboxList);
 while (iterator.hasNext()) {
 NmMailbox *box = iterator.next();
 mailboxIdList.append(box->id());
 delete box;
 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);
+TInt rcode = mFSfw->ListMailBoxes(id, mailBoxes);
-if ( rcode == NmNoError ) {
+if (rcode == NmNoError) {
 // convert mailbox data to QT classes
-NmMailbox* box(0);
+NmMailbox *box(NULL);
-for(TInt i=0;i<mailBoxes.Count();i++) {
+for (TInt i(0) ; i < mailBoxes.Count(); i++) {
 box = NULL;
 if (mailBoxes[i]) {
 box = mailBoxes[i]->GetNmMailbox();
 }
 if (box) {
 mailboxList.append(box);
 }
 }
 }
-	mailBoxes.ResetAndDestroy();
+mailBoxes.ResetAndDestroy();
 return rcode;
 }
 /*!
 Get a pointer to a new mailbox object for the mailbox identified by id.
 \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 )
+int NmFrameworkAdapter::getFolderById(const NmId& mailboxId, const NmId& folderId, NmFolder*& folder)
 {
 NM_FUNCTION;
-TRAPD(err, getFolderByIdL( mailboxId, folderId, folder ) );
+TRAPD(err, getFolderByIdL(mailboxId, folderId, folder));
 return err;
 }
 /*!
 Leaving version of getFolderById function
 */
-void NmFrameworkAdapter::getFolderByIdL( const NmId& mailboxId, const NmId& folderId, NmFolder*& folder )
+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) {
-	fsFolder = mFSfw->GetFolderByUidL(TFSMailMsgId(mailboxId), TFSMailMsgId(folderId));
+folder = fsFolder->GetNmFolder();
-	if (fsFolder)
+delete fsFolder;
-	{
+fsFolder = NULL;
-	folder = fsFolder->GetNmFolder();
+} else {
-	delete fsFolder;
+User::Leave(KErrNotFound);
-	fsFolder = NULL;
+}
-	}
+}
-	else
-	    {
-User::Leave(KErrNotFound);
-	    }
-		}
-}
 /*!
 Returns message from the store together with whole message part structure
 const NmId& messageId,
 NmMessage*& message)
 {
 NM_FUNCTION;
-TRAPD(err, getMessageByIdL(mailboxId,folderId,messageId,message));
+TRAPD(err, getMessageByIdL(mailboxId, folderId, messageId, message));
 return err;
 }
 /*!
 Leaving version of getMessageById function
 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 mailboxId Id of the mailbox containing the folder.
-	\param folderList Reference to a pointer list to receive pointers to the folders.
+\param folderList Reference to a pointer list to receive pointers to the folders.
-	\return Error code.
+\return Error code.
 */
 int NmFrameworkAdapter::listFolders(
 const NmId& mailboxId,
 QList<NmFolder*>& folderList)
 {
 NM_FUNCTION;
+int err(NmNoError);
-CFSMailBox* currentMailbox = NULL;
+CFSMailBox* currentMailbox(NULL);
-TRAPD (err, currentMailbox = mFSfw->GetMailBoxByUidL(mailboxId));
+TRAP(err, currentMailbox = mFSfw->GetMailBoxByUidL(mailboxId));
-if (KErrNone == err) {
+if (KErrNone == err && currentMailbox) {
 RPointerArray<CFSMailFolder> folders = currentMailbox->ListFolders();
 for (int i = 0; i < folders.Count(); i++) {
 folderList.append(folders[i]->GetNmFolder());
 }
-return KErrNone;
+delete currentMailbox;
-}
+currentMailbox = NULL;
-else {
+} else {
-return err;
+err = NmNotFoundError;
 }
+return err;
 }
 /*!
 Fetches all the messages from the given folder and appends their meta data
 CFSMailFolder *folder,
 QList<NmMessageEnvelope*> &messageEnvelopeList,
 const int maxEnvelopeCount)
 {
 NM_FUNCTION;
+// validity of input parameters is checked in calling function
-if (!folder || maxEnvelopeCount < 1) {
-return;
-}
 int blockSize = NmListMessagesBlock;
 int maxItemCount = NmMaxItemsInMessageList;
 if (maxEnvelopeCount < NmMaxItemsInMessageList) {
 maxItemCount = maxEnvelopeCount;
 QList<NmMessageEnvelope*> &messageEnvelopeList,
 const int maxAmountOfEnvelopes)
 {
 NM_FUNCTION;
-TInt err = KErrNone;
+TInt err(KErrNone);
 TRAP(err, listMessagesL(mailboxId,folderId, messageEnvelopeList,maxAmountOfEnvelopes) );
 return err;
 }
 QList<NmMessage*> &messageList,
 const int maxAmountOfEnvelopes)
 {
 NM_FUNCTION;
-CFSMailBox * currentMailbox(NULL);
+CFSMailBox* currentMailbox(NULL);
 CFSMailFolder* folder(NULL);
 //If we are requesting 0 or less mails so we can return
 if( maxAmountOfEnvelopes <= 0)
 {
 CFSMailBox *mailbox(NULL);
 TRAPD(err, mailbox = mFSfw->GetMailBoxByUidL(mailboxId));
 if (err == KErrNone && mailbox) {
 mailbox->CancelSearch();
+delete mailbox;
+mailbox = NULL;
 }
 return err;
 }
 // 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) {
 mailbox->SearchL(strings, sortCriteria, searchObserver);
 // Clean up.
 strings.ResetAndDestroy();
 CleanupStack::Pop(&strings);
+CleanupStack::PopAndDestroy(mailbox);
 }
 }
 /*!
 TFSMailMsgId fsMboxId(mailboxId);
 TFSMailMsgId fsFolderId(folderId);
 TFSMailMsgId fsMsgId(messageId);
 TFSMailMsgId fsMsgPartId(messagePartId);
-CFSMailMessage* fsMessage = NULL;
+CFSMailMessage* fsMessage(NULL);
-int error = KErrNone;
+int error(KErrNone);
 TRAP(error, fsMessage = mFSfw->GetMessageByUidL(fsMboxId, fsFolderId,
 fsMsgId, details) );
-CFSMailMessagePart* fsMessagePart = NULL;
+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.
 {
 NM_FUNCTION;
 TFSMailMsgId folderId;
 NmId resultId(0);
-CFSMailBox * currentMailbox(NULL);
+CFSMailBox* currentMailbox(NULL);
-TRAPD(error, currentMailbox = mFSfw->GetMailBoxByUidL(mailboxId) );
+TRAPD(error, currentMailbox = mFSfw->GetMailBoxByUidL(mailboxId));
-if( !currentMailbox || error != KErrNone ) {
+if(!currentMailbox || error != KErrNone) {
-	return resultId;
+return resultId;
 }
 switch(folderType) {
-	case NmFolderInbox:
+case NmFolderInbox:
-		folderId = currentMailbox->GetStandardFolderId( EFSInbox );
+folderId = currentMailbox->GetStandardFolderId(EFSInbox);
-		break;
+break;
-	case NmFolderOutbox:
+case NmFolderOutbox:
-		folderId = currentMailbox->GetStandardFolderId( EFSOutbox );
+folderId = currentMailbox->GetStandardFolderId(EFSOutbox);
-		break;
+break;
-	case NmFolderDrafts:
+case NmFolderDrafts:
-		folderId = currentMailbox->GetStandardFolderId( EFSDraftsFolder );
+folderId = currentMailbox->GetStandardFolderId(EFSDraftsFolder);
-		break;
+break;
-	case NmFolderSent:
+case NmFolderSent:
-		folderId = currentMailbox->GetStandardFolderId( EFSSentFolder );
+folderId = currentMailbox->GetStandardFolderId(EFSSentFolder);
-		break;
+break;
-	case NmFolderDeleted:
+case NmFolderDeleted:
-		folderId = currentMailbox->GetStandardFolderId( EFSDeleted );
+folderId = currentMailbox->GetStandardFolderId(EFSDeleted);
-		break;
+break;
-	case NmFolderOther:
+case NmFolderOther:
-	default:
+default:
-		folderId = currentMailbox->GetStandardFolderId( EFSOther );
+folderId = currentMailbox->GetStandardFolderId(EFSOther);
-		break;
+break;
 }
 delete currentMailbox;
 currentMailbox = NULL;
 int NmFrameworkAdapter::refreshMailbox(NmId mailboxId)
 {
 NM_FUNCTION;
 TRAPD(err, RefreshMailboxL(mailboxId)); // return value not used
-return ( err == KErrNone ) ? NmNoError : NmGeneralError;
+return (err == KErrNone) ? NmNoError : NmGeneralError;
 }
 /*!
 Connect to mailbox if not already connected and refresh.
 int NmFrameworkAdapter::goOnline(const NmId& mailboxId)
 {
 NM_FUNCTION;
 TRAPD(err, GoOnlineL(mailboxId)); // return value not used
-return ( err == KErrNone ) ? NmNoError : NmGeneralError;
+return (err == KErrNone) ? NmNoError : NmGeneralError;
 }
 /*!
 Disconnect to mailbox if not already disconnected.
 int NmFrameworkAdapter::goOffline(const NmId& mailboxId)
 {
 NM_FUNCTION;
 TRAPD(err, GoOfflineL(mailboxId)); // return value not used
-return ( err == KErrNone ) ? NmNoError : NmGeneralError;
+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
 CFSMailMessagePart* cfsPart = CFSMailMessagePart::NewLC(messageId,messagePart);
 cfsPart->SetMailBoxId(TFSMailMsgId(mailboxId));
 cfsPart->SetFolderId(TFSMailMsgId(folderId));
 QString contentType = messagePart.contentType();
-if (cfsPart && contentType.startsWith(NmContentTypeTextPlain)) {
+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 {
-else if (cfsPart){
 RFile file = cfsPart->GetContentFileL();
 TInt fileSize = 0;
 file.Size(fileSize);
 if (fileSize != 0) {
 HBufC8* data = HBufC8::NewLC(fileSize);
 TInt dummyPos = 0;
 file.Seek(ESeekStart, dummyPos);
 User::LeaveIfError(file.Read(dataPtr));
 }
-if (contentType.startsWith(NmContentTypeTextHtml) || contentType.contains( NmContentDescrAttachmentHtml )) {
+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);
 if (!codec) {
 codec = QTextCodec::codecForName("UTF-8");
 }
 QString encodedStr = codec->toUnicode(msgBytes);
 messagePart.setTextContent(encodedStr, contentType);
-}
+} else {
-else {
 messagePart.setBinaryContent(QByteArray(
 reinterpret_cast<const char*>(dataPtr.Ptr()), fileSize), contentType);
 }
 CleanupStack::PopAndDestroy(data);
 }
 file.Close();
 }
-else {
-// null cfsPart
-User::Leave(KErrNotFound);
-}
 CleanupStack::PopAndDestroy(cfsPart);
 }
 /*!
 Deletes the listed messages from specific mailbox and folder.
 \param messageIdList List of ids of the messages to be deleted.
 \return Error code.
 */
 int NmFrameworkAdapter::deleteMessages(
-	const NmId &mailboxId,
+const NmId &mailboxId,
-	const NmId &folderId,
+const NmId &folderId,
-	const QList<NmId> &messageIdList)
+const QList<NmId> &messageIdList)
 {
 NM_FUNCTION;
-TInt err = NmNoError;
+TInt err(NmNoError);
 RArray<TFSMailMsgId> messageIds;
-for (TInt i=0; i<messageIdList.size(); i++) {
+for (TInt i(0); i < messageIdList.size(); i++) {
 err = messageIds.Append(TFSMailMsgId(messageIdList[i]));
-if (err!=NmNoError) {
+if (err != NmNoError) {
 break;
 }
 }
 if (NmNoError == err) {
 TRAP(err, mFSfw->DeleteMessagesByUidL(TFSMailMsgId(mailboxId), TFSMailMsgId(folderId), messageIds));
 }
 messageIds.Close();
-return ( err == NmNoError ) ? NmNoError : NmGeneralError;
+return (err == NmNoError) ? NmNoError : NmGeneralError;
 }
 /*!
 Starts an async operation to store listed message envelopes to the given mailbox
 \param envelopeList List of the envelope objects to store.
 \return NmStoreEnvelopesOperation
 */
 QPointer<NmStoreEnvelopesOperation> NmFrameworkAdapter::storeEnvelopes(
-	const NmId &mailboxId,
+const NmId &mailboxId,
-	const NmId &folderId,
+const NmId &folderId,
-	const QList<const NmMessageEnvelope*> &envelopeList)
+const QList<const NmMessageEnvelope*> &envelopeList)
 {
 NM_FUNCTION;
 Q_UNUSED(folderId);
 QPointer<NmStoreEnvelopesOperation> operation(NULL);
 RPointerArray<CFSMailMessage> envelopeMessages;
-int count = envelopeList.count();
+int count(envelopeList.count());
 for(int i(0); i < count; i++) {
 TRAP_IGNORE(envelopeMessages.AppendL(mailMessageFromEnvelopeL(*envelopeList.at(i))));
 }
 if (envelopeMessages.Count()) {
 // Mail related events:
 // signal:
 // void messageEvent(
 //      NmMessageEvent event,
 //      const NmId &folderId,
-//      QList<NmId> &messageIds);
+//      QList<NmId> &messageIds
+//      const NmId& mailboxId);
 //
 // enum NmMessageEvent
 //   NmMessageCreated,
 //   NmMessageChanged,
 //   NmMessageDeleted
 emit connectionEvent(Disconnected, id, NmConnectionError);
 }
 else {
 emit connectionEvent(Disconnected, id, NmNoError);
 }
-			}
+}
 break;
 default:
 break;
 }
 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;
 mFSfw->UnsubscribeMailboxEvents(mailboxId, *this);
 }
-NmId NmFrameworkAdapter::getMailboxIdByMailMsgId(TFSMailMsgId mailbox)
-{
-NM_FUNCTION;
-NmId nmId(0);
-QList<NmId> mailboxIds;
-listMailboxIds(mailboxIds);
-QListIterator<NmId> iterator(mailboxIds);
-while (iterator.hasNext()) {
-nmId = iterator.next();
-if (nmId.id32() == mailbox.Id()) {
-break;
-}
-}
-mailboxIds.clear();
-return nmId;
-}
 /*!
 Leaving version of removeMessage
 */
 void NmFrameworkAdapter::removeMessageL(
 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 < messageIds.count(); i++) {
+for (TInt i = 0; i < count; i++) {
 NmId tmpId(messageIds[i]);
 messages.AppendL(TFSMailMsgId(tmpId));
 }
-CFSMailBox* mailBox = NULL;
+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;
+return oper;
 }
 /*!
 Add attachment into the given message.
 */
 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;
 */
 NmConnectState NmFrameworkAdapter::connectionState(const NmId& mailboxId) const
 {
 NM_FUNCTION;
-CFSMailBox* mailBox = NULL;
+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;
 currentMailbox = mFSfw->GetMailBoxByUidL(mailboxId);
 if(currentMailbox) {
 CleanupStack::PushL(currentMailbox);
 result = currentMailbox->RefreshNowL();
 CleanupStack::PopAndDestroy(currentMailbox);
-currentMailbox = NULL;
 }
 return result;
 }
 /*!
 currentMailbox = mFSfw->GetMailBoxByUidL(mailboxId);
 if(currentMailbox) {
 CleanupStack::PushL(currentMailbox);
 currentMailbox->GoOnlineL();
 CleanupStack::PopAndDestroy(currentMailbox);
-currentMailbox = NULL;
 }
 return result;
 }
 /*!
 */
 int NmFrameworkAdapter::GoOfflineL(const NmId& mailboxId)
 {
 NM_FUNCTION;
-	int result(KErrNotFound);
+int result(KErrNotFound);
 CFSMailBox *currentMailbox(NULL);
 currentMailbox = mFSfw->GetMailBoxByUidL(mailboxId);
 if(currentMailbox) {
 CleanupStack::PushL(currentMailbox);
-		currentMailbox->GoOfflineL();
+currentMailbox->GoOfflineL();
 CleanupStack::PopAndDestroy(currentMailbox);
-currentMailbox = NULL;
 }
 return result;
 }
 /*!
 handles mailbox related events
 */
-void NmFrameworkAdapter::handleMailboxEvent( TFSMailMsgId mailbox, NmMailboxEvent event)
+void NmFrameworkAdapter::handleMailboxEvent(TFSMailMsgId mailbox, NmMailboxEvent event)
 {
 NM_FUNCTION;
 QList<NmId> mailboxIds;
-NmId nmId;
+NmId nmId = mailbox.GetNmId();
-if (event == NmMailboxDeleted ||
-event == NmMailboxCreated ||
-event == NmMailboxChanged) {
-		nmId = mailbox.GetNmId();
-} else {
-		nmId = getMailboxIdByMailMsgId(mailbox);
-}
 mailboxIds.append(nmId);
 emit mailboxEvent(event, mailboxIds);
 }
 /*!

changeset 65	478bc57ad291
parent 59	16ed8d08d0b1
child 66	084b5b1f02a7