FCL/sf/app/commonemail: comparison emailservices/emailclientapi/src/emailmessage.cpp

equal deleted inserted replaced

-:dcf0eedfc1a3
+:d189ee25cf9d
 /*
-* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+* Copyright (c) 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".
 #include "emailinterfacefactoryimpl.h"
 #include "emailcontent.h"
 #include "emailtextcontent.h"
 #include "emailmultipart.h"
 #include "emailattachment.h"
-#include "cfsmailplugin.h"
+#include "CFSMailPlugin.h"
-#include "FreestyleEmailUiConstants.h"
+#include "CFSMailClient.h"
-#include "cfsmailclient.h"
+#include <xqservicerequest.h>
+#include "email_services_api.h"
+const TInt KSendMessageRequestId = 100;
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
 CEmailMessage* CEmailMessage::NewL( CPluginData& aPluginData,
 const TDataOwner aOwner )
 {
 CEmailMessage* message = new ( ELeave ) CEmailMessage( aPluginData, aFsMessage, aOwner );
 CleanupStack::PushL( message );
 message->ConstructL();
-CleanupStack::Pop();
+CleanupStack::Pop( message );
 return message;
 }
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
 CEmailMessage::CEmailMessage(
 CPluginData& aPluginData,
 CFSMailMessage *aFsMessage,
 const TDataOwner aOwner)
 : iPluginData( aPluginData ), iPluginMessage( aFsMessage ), iOwner( aOwner )
 {
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
 void CEmailMessage::ConstructL()
 {
+User::LeaveIfNull( iPluginMessage );
 iPlugin = iPluginData.ClaimInstanceL();
 if ( iPluginMessage )
 {
 iMessageId = TMessageId(
 iPluginMessage->GetMessageId().Id(),
 iPluginMessage->GetFolderId().Id(),
 iPluginMessage->GetMailBoxId().Id() );
 // Copy the message flags
 InitializeFlagValues();
 }
 }
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
 CEmailMessage::~CEmailMessage()
 {
 delete iPluginMessage;
 delete iSender;
 delete iReplyTo;
 delete iTextContent;
 delete iContent;
 iPluginData.ReleaseInstance();
 // -----------------------------------------------------------------------------
 void CEmailMessage::Release()
 {
 if ( iOwner == EClientOwns )
 {
 delete this;
 }
 }
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
 const TMessageId& CEmailMessage::MessageId() const
 {
 return iMessageId;
 }
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
 MEmailAddress* CEmailMessage::SenderAddressL() const
 {
+User::LeaveIfNull( iPluginMessage );
 CFSMailAddress* fsAddress = iPluginMessage->GetSender();
-if (fsAddress)
+if ( fsAddress )
 {
-if (!iSender)
+if ( !iSender )
 {
 iSender = CEmailAddress::NewL( MEmailAddress::ESender, EAPIOwns );
 }
 iSender->SetAddressL(fsAddress->GetEmailAddress());
 iSender->SetDisplayNameL(fsAddress->GetDisplayName());
 delete iSender;
 iSender = NULL;
 }
 return iSender;
 }
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
 MEmailAddress* CEmailMessage::ReplyToAddressL() const
 {
+User::LeaveIfNull( iPluginMessage );
 const CFSMailAddress& fsAddress = iPluginMessage->GetReplyToAddress();
 if ( &fsAddress )
 {
-if (!iReplyTo)
+if ( !iReplyTo )
 {
 iReplyTo = CEmailAddress::NewL( MEmailAddress::EReplyTo, EAPIOwns );
 }
 iReplyTo->SetAddressL( fsAddress.GetEmailAddress() );
 iReplyTo->SetDisplayNameL( fsAddress.GetDisplayName() );
 delete iReplyTo;
 iReplyTo = NULL;
 }
 return iReplyTo;
 }
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+void CEmailMessage::SetReplyToAddressL( const MEmailAddress& aSender )
+{
+User::LeaveIfNull( iPluginMessage );
-// -----------------------------------------------------------------------------
-//
-// -----------------------------------------------------------------------------
-void CEmailMessage::SetReplyToAddressL( const MEmailAddress& aSender )
-{
 CFSMailAddress *fsAddress = CFSMailAddress::NewLC();
-if (!iReplyTo)
+if ( !iReplyTo )
 {
-iReplyTo = CEmailAddress::NewL( MEmailAddress::EReplyTo, EAPIOwns);
+iReplyTo = CEmailAddress::NewL( MEmailAddress::EReplyTo, EAPIOwns );
 }
 fsAddress->SetDisplayName( aSender.DisplayName() );
 fsAddress->SetEmailAddress( aSender.Address() );
 iPluginMessage->SetReplyToAddress( fsAddress );
 iReplyTo->SetAddressL( fsAddress->GetEmailAddress() );
 iReplyTo->SetDisplayNameL( fsAddress->GetDisplayName() );
 CleanupStack::Pop();
 }
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
 TInt CEmailMessage::GetRecipientsL( const MEmailAddress::TRole aRole,
 REmailAddressArray& aRecipients ) const
 {
 if( aRole == MEmailAddress::EReplyTo ||
-aRole == MEmailAddress::ESender    )
+aRole == MEmailAddress::ESender )
 {
 User::Leave( KErrArgument );
 }
 else
 {
+User::LeaveIfNull( iPluginMessage );
 if( aRole == MEmailAddress::ETo ||
 aRole == MEmailAddress::EUndefined )
 {
-RPointerArray<CFSMailAddress>& toRecipients =
+const RPointerArray<CFSMailAddress>& toRecipients =
 iPluginMessage->GetToRecipients();
 ConvertAddressArrayL(
 MEmailAddress::ETo,
 toRecipients, aRecipients );
 }
 if( aRole == MEmailAddress::ECc ||
 aRole == MEmailAddress::EUndefined )
 {
-RPointerArray<CFSMailAddress>& ccRecipients =
+const RPointerArray<CFSMailAddress>& ccRecipients =
 iPluginMessage->GetCCRecipients();
 ConvertAddressArrayL(
 MEmailAddress::ECc,
 ccRecipients, aRecipients );
 }
 if( aRole == MEmailAddress::EBcc ||
 aRole == MEmailAddress::EUndefined )
 {
-RPointerArray<CFSMailAddress>& bccRecipients =
+const RPointerArray<CFSMailAddress>& bccRecipients =
 iPluginMessage->GetBCCRecipients();
 ConvertAddressArrayL(
 MEmailAddress::EBcc,
 bccRecipients, aRecipients );
 }
 }
 return aRecipients.Count();
 }
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
 void CEmailMessage::SetRecipientsL( const MEmailAddress::TRole aRole,
 REmailAddressArray& aRecipients )
 {
 TInt count( aRecipients.Count() );
 for( TInt i=0;i<count;i++ )
 {
 const MEmailAddress* address = aRecipients[i];
 CFSMailAddress* fsAddress = CFSMailAddress::NewLC();
 fsAddress->SetEmailAddress( address->Address() );
 fsAddress->SetDisplayName( address->DisplayName() );
+User::LeaveIfNull( iPluginMessage );
 if( aRole == MEmailAddress::ETo )
 {
 iPluginMessage->AppendToRecipient( fsAddress );
 }
 else if( aRole == MEmailAddress::ECc )
 User::Leave( KErrArgument );
 }
 CleanupStack::Pop( fsAddress );
 }
 }
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
-void CEmailMessage::RemoveRecipientL( const MEmailAddress& aRecipient )
+void CEmailMessage::RemoveRecipientL( const MEmailAddress& /*aRecipient*/ )
 {
-TInt err( KErrNotFound );
+User::Leave( KErrNotSupported );
-RPointerArray<CFSMailAddress>* recipients = NULL;
+}
-switch (aRecipient.Role())
-{
-case MEmailAddress::ETo:
-recipients = &iPluginMessage->GetToRecipients();
-break;
-case MEmailAddress::ECc:
-recipients = &iPluginMessage->GetCCRecipients();
-break;
-case MEmailAddress::EBcc:
-recipients = &iPluginMessage->GetBCCRecipients();
-break;
-default:
-User::Leave( KErrArgument );
-break;
-}
-for( TInt i = 0; i < recipients->Count(); i++ )
-{
-if ( !aRecipient.Address().Compare( (*recipients)[i]->GetEmailAddress() ) )
-{
-recipients->Remove(i);
-err = KErrNone;
-// We could break now. But let's loop if there are several entries
-}
-}
-User::LeaveIfError( err );
-}
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
 TPtrC CEmailMessage::Subject() const
 {
+if ( !iPluginMessage )
+return KNullDesC();
 return iPluginMessage->GetSubject();
 }
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
-void  CEmailMessage::SetSubjectL( const TPtrC& aSubject)
+void  CEmailMessage::SetSubjectL( const TPtrC& aSubject )
 {
+User::LeaveIfNull( iPluginMessage );
 iPluginMessage->SetSubject( aSubject );
 }
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
 TTime CEmailMessage::Date() const
 {
-return iPluginMessage->GetDate();
+TTime time;
+if ( iPluginMessage ) {
+time = iPluginMessage->GetDate();
+}
+return time;
 }
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
 // -----------------------------------------------------------------------------
 void CEmailMessage::SetFlag( const TUint aFlag )
 {
 iFlags |= aFlag;
 TUint flag = MapFlags( aFlag );
-iPluginMessage->SetFlag( flag );
+if ( iPluginMessage )
-}
+iPluginMessage->SetFlag( flag );
+}
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
 void CEmailMessage::ResetFlag( const TUint aFlag )
 {
 iFlags &= ~aFlag;
 TUint flag = MapFlags( aFlag );
-iPluginMessage->ResetFlag( flag );
+if ( iPluginMessage )
+iPluginMessage->ResetFlag( flag );
 }
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
 void CEmailMessage::InitializeFlagValues()
 {
+if ( !iPluginMessage )
+return;
 // 1st reset member value, then start copying different flags
 iFlags = 0;
 // EFlag_Read
 if ( iPluginMessage->IsFlagSet( EFSMsgFlag_Read ) )
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
 MEmailMessageContent* CEmailMessage::ContentL() const
 {
-if (iTextContent)
+if ( iTextContent )
 {
 return iTextContent;
 }
-if (iContent)
+if ( iContent )
 {
 return iContent;
 }
+User::LeaveIfNull( iPluginMessage );
 RPointerArray<CFSMailMessagePart> parts;
 CleanupResetAndDestroyPushL( parts );
 iPluginMessage->ChildPartsL( parts );
 TInt count( parts.Count() );
 if( count == 0 )
 /* No content, return NULL */
 CleanupStack::PopAndDestroy( &parts ); // in case heap allocated but not used
 return NULL;
 }
 CFSMailMessagePart* part = parts[0];
 TContentType contentType( part->GetContentType() );
 TMessageContentId msgContentId = TMessageContentId(
 part->GetPartId().Id(),
 iMessageId.iId,
 iMessageId.iFolderId.iId,
 iMessageId.iFolderId.iMailboxId );
 if ( contentType.Equals( KFSMailContentTypeTextPlain ) ||
 contentType.Equals( KFSMailContentTypeTextHtml ) )
 {
 iTextContent = CEmailTextContent::NewL(iPluginData, msgContentId, part, EAPIOwns );
 parts[0] = NULL; // ownership of part transferred
 }
 iContent = CEmailMultipart::NewL(iPluginData, msgContentId, part, EAPIOwns);
 parts[0] = NULL; // ownership of part transferred
 }
 CleanupStack::PopAndDestroy( &parts ); // parts
 if (iTextContent)
 {
 return iTextContent;
 }
 return iContent;
 }
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
 void CEmailMessage::SetContentL( const MEmailMessageContent*  aContent )
 {
+User::LeaveIfNull( aContent );
 MEmailTextContent* textContent = aContent->AsTextContentOrNull();
-if (textContent)
+if ( textContent )
 {
-if (iTextContent)
+if ( iTextContent )
 {
 delete iTextContent; // Destroy old content
 }
-iTextContent = dynamic_cast<CEmailTextContent*>(textContent);
+iTextContent = dynamic_cast<CEmailTextContent*>( textContent );
-		if ( iTextContent )
+if ( iTextContent )
-			{
+{
-			iTextContent->SetOwner( EAPIOwns );
+iTextContent->SetOwner( EAPIOwns );
-			}
+}
 return;
 }
 MEmailMultipart* mPart = aContent->AsMultipartOrNull();
-if (mPart)
+if ( mPart )
 {
-if (iContent)
+if ( iContent )
 {
 delete iContent;
 }
-iContent = dynamic_cast<CEmailMultipart*>(mPart);
+iContent = dynamic_cast<CEmailMultipart*>( mPart );
-		if ( iContent )
+if ( iContent )
-			{
+{
-			iContent->SetOwner( EAPIOwns );
+iContent->SetOwner( EAPIOwns );
-			}
+}
 }
 }
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
 void CEmailMessage::SetPlainTextBodyL( const TDesC& aPlainText )
 {
-if (iTextContent)
+if ( iTextContent )
 {
 iTextContent->SetTextL( MEmailTextContent::EPlainText, aPlainText );
 return;
 }
+User::LeaveIfNull( iPluginMessage );
 CFSMailMessagePart* msgTextPart = iPluginMessage->PlainTextBodyPartL();
 if( !msgTextPart )
 {
 msgTextPart = iPluginMessage->NewChildPartL( TFSMailMsgId(), KFSMailContentTypeTextPlain );
 }
 CleanupStack::PushL( msgTextPart );
-TMessageContentId msgContentId = TMessageContentId(
+TMessageContentId msgContentId = MessageContentId( msgTextPart->GetPartId().Id() );
-msgTextPart->GetPartId().Id(),
-iMessageId.iId,
+msgTextPart->SetContentType( KFSMailContentTypeTextPlain );
-iMessageId.iFolderId.iId,
-iMessageId.iFolderId.iMailboxId );
-msgTextPart->SetContentType( KFSMailContentTypeTextPlain );
 iTextContent = CEmailTextContent::NewL( iPluginData, msgContentId, msgTextPart, EAPIOwns );
 if (iTextContent)
 {
 iTextContent->SetTextL( MEmailTextContent::EPlainText, aPlainText );
 }
-CleanupStack::Pop(); // msgTextPart
+CleanupStack::Pop( msgTextPart );
 return;
 }
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
 MEmailAttachment* CEmailMessage::AddAttachmentL( const TDesC& aFullPath )
 {
-CFSMailMessagePart* part = iPluginMessage->AddNewAttachmentL(aFullPath, TFSMailMsgId());
+User::LeaveIfNull( iPluginMessage );
+CFSMailMessagePart* part = iPluginMessage->AddNewAttachmentL( aFullPath, TFSMailMsgId() );
 CleanupStack::PushL( part );
-CEmailAttachment* att = CEmailAttachment::NewLC(iPluginData, iMsgContentId, part, EAPIOwns);
+CEmailAttachment* att = CEmailAttachment::NewLC( iPluginData, iMsgContentId, part, EAPIOwns );
 iAttachments.AppendL( att );
-CleanupStack::Pop(2); // part, att
+CleanupStack::Pop( 2, part );
 return att;
 }
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
 MEmailAttachment* CEmailMessage::AddAttachmentL( RFile& aFile )
 {
+User::LeaveIfNull( iPluginMessage );
 TBufC8 <1> mime;
-CFSMailMessagePart* part = iPluginMessage->AddNewAttachmentL(aFile, mime);
+CFSMailMessagePart* part = iPluginMessage->AddNewAttachmentL( aFile, mime );
 CleanupStack::PushL( part );
-CEmailAttachment* att = CEmailAttachment::NewLC(iPluginData, iMsgContentId, part, EAPIOwns);
+CEmailAttachment* att = CEmailAttachment::NewLC( iPluginData, iMsgContentId, part, EAPIOwns );
 iAttachments.AppendL( att );
-CleanupStack::Pop(2); // part, att
+CleanupStack::Pop( 2, part );
 return att;
 }
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
 TInt CEmailMessage::GetAttachmentsL( REmailAttachmentArray& aAttachments )
 {
+User::LeaveIfNull( iPluginMessage );
 RPointerArray<CFSMailMessagePart> attachments;
 CleanupResetAndDestroyPushL( attachments );
-iPluginMessage->AttachmentListL(attachments);
+iPluginMessage->AttachmentListL( attachments );
 const TInt count( attachments.Count() );
 for (TInt i = 0; i < count; i++)
 {
-TMessageContentId msgContentId = TMessageContentId(
+TMessageContentId msgContentId = MessageContentId( attachments[i]->GetPartId().Id() );
-attachments[i]->GetPartId().Id(),
-iMessageId.iId,
+CEmailAttachment* att = CEmailAttachment::NewL(
-iMessageId.iFolderId.iId,
+iPluginData, msgContentId, attachments[i], EClientOwns );
-iMessageId.iFolderId.iMailboxId );
+aAttachments.AppendL( att );
-CEmailAttachment* att = CEmailAttachment::NewL(iPluginData, msgContentId, attachments[i], EClientOwns);
+}
+CleanupStack::Pop( &attachments );
-aAttachments.AppendL(att);
+return count;
 }
-CleanupStack::Pop(); // attachments
-return count;
+// -----------------------------------------------------------------------------
-}
+//
+// -----------------------------------------------------------------------------
+void CEmailMessage::RemoveAttachmentL( const MEmailAttachment& /*aAttachment*/ )
+{
+User::Leave( KErrNotSupported );
+}
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+const TFolderId& CEmailMessage::ParentFolderId() const
+{
+return iMessageId.iFolderId;
+}
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+void CEmailMessage::SaveChangesL()
+{
+User::LeaveIfNull( iPluginMessage );
-// -----------------------------------------------------------------------------
-//
-// -----------------------------------------------------------------------------
-void CEmailMessage::RemoveAttachmentL( const MEmailAttachment& aAttachment  )
-{
-iPluginMessage->RemoveChildPartL(FsMsgId( iPluginData, aAttachment.Id()));
-}
-// -----------------------------------------------------------------------------
-//
-// -----------------------------------------------------------------------------
-const TFolderId& CEmailMessage::ParentFolderId() const
-{
-return iMessageId.iFolderId;
-}
-// -----------------------------------------------------------------------------
-//
-// -----------------------------------------------------------------------------
-void CEmailMessage::SaveChangesL()
-{
 TFSMailMsgId mailboxId(
 FsMsgId( iPluginData, iMessageId.iFolderId.iMailboxId ) );
 iPlugin->StoreMessageL( mailboxId, *iPluginMessage );
 }
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
 void CEmailMessage::SendL()
 {
+User::LeaveIfNull( iPluginMessage );
+if ( iEventLoop.isRunning() )
+User::Leave( KErrInUse );
 SaveChangesL();
-iPlugin->SendMessageL( *iPluginMessage );
+iError = KErrNone;
-}
+iPlugin->SendMessageL( *iPluginMessage, *this, KSendMessageRequestId );
+iEventLoop.exec();
-// -----------------------------------------------------------------------------
-//
+User::LeaveIfError( iError );
-// -----------------------------------------------------------------------------
+}
-void CEmailMessage::ConvertAddressArrayL(
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+void CEmailMessage::RequestResponseL( TFSProgress aEvent, TInt aRequestId )
+{
+iError = aEvent.iError;
+if ( aRequestId == KSendMessageRequestId &&
+aEvent.iProgressStatus == TFSProgress::EFSStatus_RequestComplete )
+iEventLoop.quit();
+}
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+void CEmailMessage::ConvertAddressArrayL(
 const MEmailAddress::TRole aRole,
-RPointerArray<CFSMailAddress>& aSrc,
+const RPointerArray<CFSMailAddress>& aSrc,
 REmailAddressArray& aDst ) const
 {
 for ( TInt i=0; i<aSrc.Count(); i++ )
 {
 CEmailAddress* recipient = CreateAddressLC( aRole, *aSrc[i] );
 }
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
-//
+CEmailAddress* CEmailMessage::CreateAddressLC(
-CEmailAddress* CEmailMessage::CreateAddressLC(
 const MEmailAddress::TRole aRole,
 CFSMailAddress& aFsAddress ) const
 {
 CEmailAddress* address = CEmailAddress::NewLC( aRole, EClientOwns );
 TDesC& temp1 = aFsAddress.GetEmailAddress();
 }
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
-//
 TUint CEmailMessage::MapFlags( const TUint& aFlag )
 {
 TUint flag = 0;
 switch( aFlag )
 {
 break;
 }
 return flag;
 }
-void CEmailMessage::ShowMessageViewerL( )
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+void CEmailMessage::ShowMessageViewerL()
 {
-THtmlViewerActivationData htmlData;
+bool syncronous;
-htmlData.iActivationDataType = THtmlViewerActivationData::EMailMessage;
-htmlData.iMailBoxId = FsMsgId(iPluginData, iMessageId.iFolderId.iMailboxId);
+XQServiceRequest request(
-htmlData.iFolderId = FsMsgId(iPluginData, iMessageId.iFolderId);
+emailInterfaceNameMessage,
-htmlData.iMessageId = FsMsgId(iPluginData, iMessageId);
+emailOperationViewMessage,
-TPckgBuf<THtmlViewerActivationData> pckgData( htmlData );
+syncronous );
-CVwsSessionWrapper* viewSrvSession = CVwsSessionWrapper::NewLC();
-viewSrvSession->ActivateView(TVwsViewId(KFSEmailUiUid, HtmlViewerId), KHtmlViewerOpenNew, pckgData);
+TFSMailMsgId mailboxId = FsMsgId( iPluginData, iMessageId.iFolderId.iMailboxId );
-CleanupStack::PopAndDestroy();
+TFSMailMsgId folderId = FsMsgId( iPluginData, iMessageId.iFolderId );
-}
+TFSMailMsgId messageId = FsMsgId( iPluginData, iMessageId );
-/**
+QList<QVariant> list;
-* Launches Email application and new reply message in editor.
+list.append( mailboxId.Id() );
-* The method follows "fire and forget" pattern, returns immediately.
+list.append( folderId.Id() );
-*/
+list.append( messageId.Id() );
-void CEmailMessage::ReplyToMessageL( const TBool aReplyToAll )
+request.setArguments( list );
-{
-TEditorLaunchParams editorLaunchData;
+QVariant returnValue;
-editorLaunchData.iExtra = NULL;
+if ( !request.send( returnValue ) )
-editorLaunchData.iMailboxId = FsMsgId(iPluginData, iMessageId.iFolderId.iMailboxId);
+User::Leave( KErrGeneral );
-editorLaunchData.iFolderId = FsMsgId(iPluginData, iMessageId.iFolderId);
+}
-editorLaunchData.iMsgId = FsMsgId(iPluginData, iMessageId);
-editorLaunchData.iActivatedExternally = ETrue;
+// -----------------------------------------------------------------------------
+// Launches Email application and new reply message in editor.
-TPckgBuf<TEditorLaunchParams> pckgData( editorLaunchData );
+// The method follows "fire and forget" pattern, returns immediately.
-CVwsSessionWrapper* viewSrvSession = CVwsSessionWrapper::NewLC();
+// -----------------------------------------------------------------------------
-TUid command = TUid::Uid(KEditorCmdReplyAll);
+void CEmailMessage::ReplyToMessageL( const TBool /*aReplyToAll*/ )
-if ( !aReplyToAll )
+{
-{
+User::Leave( KErrNotSupported );
-command = TUid::Uid(KEditorCmdReply);
+}
-}
-viewSrvSession->ActivateView(TVwsViewId(KFSEmailUiUid, MailEditorId), command, pckgData);
+// -----------------------------------------------------------------------------
-CleanupStack::PopAndDestroy();
+//
-}
+// -----------------------------------------------------------------------------
 void CEmailMessage::ForwardMessageL()
 {
-TEditorLaunchParams editorLaunchData;
+User::Leave( KErrNotSupported );
-editorLaunchData.iExtra = NULL;
-editorLaunchData.iMailboxId = FsMsgId(iPluginData, iMessageId.iFolderId.iMailboxId);
-editorLaunchData.iFolderId = FsMsgId(iPluginData, iMessageId.iFolderId);
-editorLaunchData.iMsgId = FsMsgId(iPluginData, iMessageId);
-editorLaunchData.iActivatedExternally = ETrue;
-TPckgBuf<TEditorLaunchParams> pckgData( editorLaunchData );
-CVwsSessionWrapper* viewSrvSession = CVwsSessionWrapper::NewLC();
-TUid command = TUid::Uid(KEditorCmdForward);
-viewSrvSession->ActivateView(TVwsViewId(KFSEmailUiUid, MailEditorId), command, pckgData);
-CleanupStack::PopAndDestroy();
 }
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
+TMessageContentId CEmailMessage::MessageContentId( TEntryId aContentId ) const
+{
+TMessageContentId msgContentId = TMessageContentId(
+aContentId,
+iMessageId.iId,
+iMessageId.iFolderId.iId,
+iMessageId.iFolderId.iMailboxId );
+return msgContentId;
+}
+// -----------------------------------------------------------------------------
 //
+// -----------------------------------------------------------------------------
 TContentType::TContentType( const TDesC& aContentType ) : iContentType( aContentType )
 {
 _LIT( KSeparator, ";" );
 TInt end = aContentType.Find( KSeparator );
 if ( end != KErrNotFound )
 }
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
-//
 TBool TContentType::Equals( const TDesC& aContentType )
 {
-	TBool ret = iContentType.CompareF( aContentType );
+TBool ret = iContentType.CompareF( aContentType );
 if ( ret == 0  )
-	return ETrue;
+return ETrue;
 else
-	return EFalse;
+return EFalse;
 }
-// End of file.
+// End of file

branch	RCL_3
changeset 63	d189ee25cf9d
parent 24	b5fbb9b25d57
child 64	3533d4323edc