FCL/sf/app/commonemail: comparison ipsservices/ipssosplugin/src/ipsplgsosbaseplugin.cpp

equal deleted inserted replaced

-:d189ee25cf9d
+:3533d4323edc
 *
 */
 #include "emailtrace.h"
 #include "ipsplgheaders.h"
+#include "FreestyleEmailUiConstants.h"
-// <qmail> FreestyleEmailUiConstants include removed
+#define FREESTYLE_EMAIL_UI_SID 0x2001E277
-// <qmail>
-#include "ipsplgsosbaseplugin.hrh"
-#include "ipsplgmailstoreroperation.h"
-#include "ipsplgmessagepartstoreroperation.h"
-#include "BasePlugin.h"
-//<Qmail>
-#include "ipssosextendedsettingsmanager.h"
-#include "ipssettingkeys.h"
-//</Qmail>
-//</qmail>
-#define FREESTYLE_EMAIL_UI_SID 0x200255BA
 const TInt KOpGranularity = 2;
-// <qmail> remove unused literals
+_LIT( KMimeTextCalRequest,  "text/calendar; method=REQUEST;" );
+_LIT( KMimeTextCalResponse, "text/calendar; method=RESPONSE;" );
+_LIT( KMimeTextCalCancel,   "text/calendar; method=CANCEL;" );
+_LIT8( KMethod, "method" );
+_LIT8( KRequest, "REQUEST" );
+_LIT8( KResponse, "RESPONSE" );
+_LIT8( KCancel, "CANCEL" );
+_LIT( KLineFeed, "\r\n");
 #ifdef __WINS__
 _LIT( KEmulatorIMEI, "123456789012345" );
 #endif // __WINS__
-//<Qmail>
+// ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
+//
-void CIpsPlgSosBasePlugin::ActiveFolderChanged(
-const TFSMailMsgId& aActiveMailboxId,
-const TFSMailMsgId& aActiveFolderId)
-{
-TRAP_IGNORE( HandleActiveFolderChangeL(aActiveMailboxId,aActiveFolderId) );
-}
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-CEmailExtension* CIpsPlgSosBasePlugin::ExtensionL( const TUid& aInterfaceUid )
-{
-if(aInterfaceUid != KEmailMailboxStateExtensionUid)
-{
-User::Leave(KErrNotSupported);
-}
-return iStateExtension;
-}
-//</Qmail>
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-// <qmail> iSettingsApi removed
 CIpsPlgSosBasePlugin::CIpsPlgSosBasePlugin( const TUint aFSPluginId ) :
 iFSPluginId( aFSPluginId ),
 iSession( NULL ),
 iMsgMapper( NULL ),
 iOperations( KOpGranularity ),
 iSmtpService( NULL ),
 iCachedEntry( NULL ),
 iCachedEmailMessage( NULL ),
 iMruList( NULL ),
 iSearch( NULL ),
+iSettingsApi( NULL ),
 iEventHandler( NULL ),
 iSessionOk( ETrue ),
 iBrandingId( NULL ),
 iIsUnderUiProcess( EFalse )
 {
 FUNC_LOG;
 }
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
-// <qmail> iSettingsApi, iWait removed
+//
 CIpsPlgSosBasePlugin::~CIpsPlgSosBasePlugin()
 {
 FUNC_LOG;
+if ( iMsvOpDeleteMessage )
+{
+iMsvOpDeleteMessage->Cancel();
+}
+if ( iWaitDeleteMessage )
+{
+iWaitDeleteMessage->Cancel();
+}
+delete iMsvOpDeleteMessage;
+iMsvOpDeleteMessage = NULL;
+delete iWaitDeleteMessage;
+iWaitDeleteMessage = NULL;
+delete icEntry;
+icEntry = NULL;
+if ( iWait.IsStarted() )
+{
+iWait.AsyncStop();
+}
 iOperations.ResetAndDestroy();
 iActivitytimers.ResetAndDestroy();
 iOperations.Close();
 iActivitytimers.Close();
 delete iSmtpService;
 delete iMruList;
 if ( iEventHandler )
 {
 iEventHandler->UnRegisterPropertyObserver( iSyncStateHandler );
 }
-delete iStateExtension;
 delete iEventHandler;
 delete iCachedEntry;
 delete iCachedEmailMessage;
 delete iMsgMapper;
 delete iSearch;
+delete iSettingsApi;
 delete iSyncStateHandler;
 delete iSession;
 delete iBrandingId;
 }
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 void CIpsPlgSosBasePlugin::BaseConstructL()
 {
 FUNC_LOG;
-iStateExtension = CIpsStateExtension::NewL(*this);
 iEventHandler = CIpsPlgEventHandler::NewL( *this );
 iSession = CMsvSession::OpenAsyncL( *iEventHandler );
 iMsgMapper = CIpsPlgMsgMapper::NewL( *iSession, *this );
 iSmtpService = CIpsPlgSmtpService::NewL( *iSession, *this );
 iMruList = CIpsPlgMruList::NewL( );
 iSearch = CIpsPlgSearch::NewL( *iSession, *this );
-	// <qmail> iSettingsApi removed
+iSettingsApi = CIpsSetDataApi::NewL( *iSession );
+iSettingsApi->GetIMEIFromThePhoneL( iIMEI );
 iSyncStateHandler = CIpsPlgSyncStateHandler::NewL(
 *iSession, *this, iOperations );
 iEventHandler->RegisterPropertyObserverL( iSyncStateHandler );
 RProcess process;
 }
 else
 {
 iIsUnderUiProcess = EFalse;
 }
-#ifndef RD_101_EMAIL
 RAlwaysOnlineClientSession aosession;
 TInt err = aosession.Connect();
 if ( err == KErrNone )
 {
 TBuf8<1> dummyBuf;
 TRAP( err, aosession.RelayCommandL(
 EServerAPIEmailDisableAOEmailPlugin,
 dummyBuf ) );
 }
 aosession.Close();
-#endif
 }
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 void CIpsPlgSosBasePlugin::CompleteConstructL()
 if ( oper.Id() == opId )
 {
 DeleteAndRemoveOperation( i, aCompletionCode );
 }
+}
-// <qmail> iWait removed
+// make draft deletion synchronous so that empty drafts are not left after application close.
+if ( iWait.IsStarted() )
+{
+iWait.AsyncStop();
 }
 }
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 iSession->GetEntry( aMailBoxId.Id(), service, tEntry );
 if ( tEntry.Connected() )
 {
 status = EFSMailBoxOnline;
 }
-else if ( ConnOpRunning( aMailBoxId ) )
+		else
-{
-status = EFSMailBoxOnline;
-}
-else
 {
 status = EFSMailBoxOffline;
 }
 }
 else
 result = CFSMailBox::NewL( aMailBoxId );
 CleanupStack::PushL( result );   // << result
 result->SetName( tEntry.iDetails );
 result->SetSettingsUid( TUid::Uid( IPS_SET_ECOM_IMPLEMENTATION_UID ) );
-// <qmail>
+iSettingsApi->GetMailboxAddressL( tEntry, address );
-CEmailAccounts* acc = CEmailAccounts::NewLC();
-TSmtpAccount smtpAcc;
-acc->GetSmtpAccountL( tEntry.iRelatedId , smtpAcc );
-CImSmtpSettings* smtpSet = new (ELeave) CImSmtpSettings();
-CleanupStack::PushL( smtpSet );
-acc->LoadSmtpSettingsL( smtpAcc, *smtpSet );
-address = smtpSet->EmailAddress().AllocL();
-CleanupStack::PopAndDestroy( 2, acc );
-// </qmail>
 CleanupStack::PushL( address ); // << address
 CFSMailAddress* fsAddress = CFSMailAddress::NewLC();    // << fsAddress
 fsAddress->SetEmailAddress( *address );
 result->SetOwnMailAddressL( fsAddress );
 CleanupStack::Pop( fsAddress ); // >> fsAddress
 TMsvId service;
 if( !iSessionOk )
 {
 User::Leave( KErrNotReady );
 }
-// <qmail> RAlwaysOnlineClientSession - related code removed
+// Create connection to Always Online
+RAlwaysOnlineClientSession aosess;
+User::LeaveIfError( aosess.Connect() );
 // Prepare the parameters to be forwarded to AO-server
 TPckg<TMsvId> param = aMailBoxId.Id();
+// Send message to server and close it
+TRAP_IGNORE( aosess.RelayCommandL( EServerAPIEmailAgentRemove, param ) );
+aosess.Close();
 // delete MRU list from cen rep
 iMruList->ClearDataL( aMailBoxId );
 iSyncStateHandler->NotifyMailboxRemove( aMailBoxId.Id() );
-// <qmail> CancelAllOnlineOperations function call removed
+CancelAllOnlineOperations( aMailBoxId );
 iSession->GetEntry( aMailBoxId.Id(), service, tEntry );
 if ( tEntry.Connected() )
 {
 DisconnectL( aMailBoxId, aOperationObserver, aRequestId, ETrue );
 }
 }
 }
 else
 {
-// <qmail> iSettingsApi removed
+iSettingsApi->RemoveAccountL( tEntry, *iSession );
 TFSProgress progress = { TFSProgress::EFSStatus_Waiting, 0, 0, KErrNone };
 progress.iProgressStatus = TFSProgress::EFSStatus_RequestComplete;
 progress.iError = KErrNone;
 TInt requestId = aRequestId;
 aOperationObserver.RequestResponseL( progress, requestId );
 FUNC_LOG;
 if( !iSessionOk )
 {
 User::Leave( KErrNotReady );
 }
-CMsvEntry* mboxEntry = iSession->GetEntryL( aMailBoxId.Id() );
-CleanupStack::PushL( mboxEntry );
+TMsvEntry tEntry;
+TMsvId serviceId;
-// <qmail> iSettingsApi removed, iBrandingId removed
+TInt status = iSession->GetEntry( aMailBoxId.Id(), serviceId, tEntry );
-CleanupStack::PopAndDestroy( mboxEntry );
+if ( status == KErrNone )
+{
+HBufC* address( NULL );
+iSettingsApi->GetMailboxAddressL( tEntry, address );
+CleanupStack::PushL( address );
+TPtrC ptr = address->Des();
+TInt index = ptr.Locate('@') + 1;
+if( index > 0 && ptr.Length() > 0 )
+{
+if( iBrandingId )
+{
+delete iBrandingId;
+iBrandingId = NULL;
+}
+ptr.Set( ptr.Right( ptr.Length() - index ) );
+iBrandingId = HBufC::NewL( ptr.Length() );
+iBrandingId->Des().Copy( ptr );
+}
+CleanupStack::PopAndDestroy( address );
+}
 return *iBrandingId;
 }
 // ----------------------------------------------------------------------------
 // Pop3 has no implementation for this virtual
 const RArray<TFSMailMsgId>& aMessageIds,
 const TFSMailMsgId& aSourceFolderId,
 const TFSMailMsgId& aDestinationFolderId )
 	{
 FUNC_LOG;
-	// Pop3 has no implementation for this virtual
 	if( aDestinationFolderId.Id() == KMsvDraftEntryId  )
 	    {
 	    MoveMessagesToDraftL(
 	        aMailBoxId,
 	        aMessageIds,
 sel->AppendL( tEntry.Id() );
 }
 }
 if( sel->Count() )
 {
-// <qmail> remove activeschedulerwait
+CIpsPlgOperationWait* wait = CIpsPlgOperationWait::NewLC();
-TMsvLocalOperationProgress progress;
 if( !aSourceFolderId.IsNullId() )
 {
 CMsvEntry* cEntry = iSession->GetEntryL( aSourceFolderId.Id() );
 CleanupStack::PushL( cEntry );
-cEntry->MoveL( *sel, aDestinationFolderId.Id(), progress );
+cEntry->MoveL(
+*sel,
+aDestinationFolderId.Id(),//KMsvDraftEntryIdValue
+wait->iStatus );
 CleanupStack::PopAndDestroy( cEntry );
 }
 else
 {
 // Message is in editing state, we can't use parent as entry
 // because it's equal to destination.
 TMsvId parent = msgEntry->Entry().Parent();
 msgEntry->SetEntryL( parent );
-msgEntry->CopyL( *sel, aDestinationFolderId.Id(), progress );
+msgEntry->CopyL(
-}
+*sel,
-User::LeaveIfError( progress.iError );
+aDestinationFolderId.Id(),//KMsvDraftEntryIdValue
-// </qmail>
+wait->iStatus );
+}
+wait->Start();
+CleanupStack::PopAndDestroy( wait ); // wait
 }
 CleanupStack::PopAndDestroy( 2, sel ); // msgEntry, sel
 }
 // ----------------------------------------------------------------------------
 if( !iSessionOk )
 {
 User::Leave( KErrNotReady );
 }
 iSession->GetEntry( aMailBoxId.Id(), service, tEntry );
-// <qmail>
-TInt state(0);
+TInt state = iSettingsApi->GetLastSyncStatusL( tEntry );
-// </qmail>
 switch( state )
 {
 case ESyncFinishedSuccessfully:
 progress.iProgressStatus = TFSProgress::EFSStatus_RequestComplete;
 break;
 {
 const CIpsPlgBaseOperation* baseOp =
 iOperations[i]->BaseOperation();
 if ( baseOp && baseOp->FSMailboxId() == aMailBoxId &&
 ( baseOp->IpsOpType() == EIpsOpTypePop3SyncOp
+|| baseOp->IpsOpType() == EIpsOpTypePop3PopulateOp
 || baseOp->IpsOpType() == EIpsOpTypeImap4SyncOp
 || baseOp->IpsOpType() == EIpsOpTypeImap4PopulateOp ) )
 {
 DeleteAndRemoveOperation( i, KErrCancel );
 }
 }
+/** <should be commented out until AO Manager API enhancements are back ported>
-#ifndef RD_101_EMAIL
 RAlwaysOnlineClientSession aosession;
 err = aosession.Connect();
 if ( err == KErrNone )
 {
 TPckgBuf<TMsvId> buf(aMailBoxId.Id());
 TRAP( err, aosession.RelayCommandL(
 EServerAPIEmailCancelAllAndDoNotDisconnect, buf ) );
 }
 aosession.Close();
-#endif
+*/
 return err;
 }
 // ----------------------------------------------------------------------------
 	}
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 CFSMailMessage* CIpsPlgSosBasePlugin::CreateMessageToSendL(
-const TFSMailMsgId& /*aMailBoxId*/ )
+const TFSMailMsgId& aMailBoxId )
 	{
-// <qmail> not used any more
+FUNC_LOG;
-User::Leave(KErrFSMailPluginNotSupported);
+CFSMailMessage* msg = iSmtpService->CreateNewSmtpMessageL( aMailBoxId );
-return NULL; // prevents compiler warning
+	return msg;
 	}
-// <qmail>
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-void CIpsPlgSosBasePlugin::CreateMessageToSendL( const TFSMailMsgId& aMailBoxId,
-MFSMailRequestObserver& aOperationObserver,
-const TInt aRequestId )
-{
-FUNC_LOG;
-// asynchronous message creation is started here to enable canceling of the operation
-TMsvPartList partList( KMsvMessagePartBody );
-CIpsPlgSingleOpWatcher* watcher = CIpsPlgSingleOpWatcher::NewLC(*this);
-//<qmail> removed mboxEntry from parameters + changed iSmtpService to pointer
-CIpsPlgCreateMessageOperation* op = CIpsPlgCreateMessageOperation::NewL(
-*iSmtpService,
-*iSession,
-watcher->iStatus,
-partList,
-aMailBoxId,
-aOperationObserver,
-aRequestId );
-//</qmail>
-watcher->SetOperation( op );
-iOperations.AppendL( watcher );
-CleanupStack::Pop( watcher );
-}
-// </qmail>
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 CFSMailMessage* CIpsPlgSosBasePlugin::CreateForwardMessageL(
-const TFSMailMsgId& /*aMailBoxId*/,
-const TFSMailMsgId& /*aOriginalMessageId*/,
-const TDesC& /*aHeaderDescriptor*/ )
-{
-// <qmail> not used any more
-User::Leave(KErrFSMailPluginNotSupported);
-return NULL; // prevents compiler warning
-}
-// <qmail>
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-void CIpsPlgSosBasePlugin::CreateForwardMessageL(
 const TFSMailMsgId& aMailBoxId,
 const TFSMailMsgId& aOriginalMessageId,
-MFSMailRequestObserver& aOperationObserver,
+const TDesC& aHeaderDescriptor )
-const TInt aRequestId,
+{
-const TDesC& /*aHeaderDescriptor*/ )
+FUNC_LOG;
-{
+CFSMailMessage* msg = iSmtpService->CreateForwardSmtpMessageL(
-FUNC_LOG;
+aMailBoxId, aOriginalMessageId );
-// asynchronous message creation is started here to enable canceling of the operation
-// 1. part of function checs that body text and all
+if ( aHeaderDescriptor != KNullDesC )
-// attachments are fetched
+{
-TMsvEntry orgMsg;
+// Ignoring trap as it is better to provide something in case of the
-TMsvId service;
+// below fix method fails than nothing.
-User::LeaveIfError( iSession->GetEntry(
+TRAP_IGNORE( FixReplyForwardHeaderL(
-aOriginalMessageId.Id(), service, orgMsg ) );
+msg,
+aMailBoxId,
-if ( orgMsg.Id() ==  KMsvNullIndexEntryIdValue )
+aOriginalMessageId,
-{
+aHeaderDescriptor ) );
-User::Leave(KErrNotFound);
+}
-}
+return msg;
-if ( ( orgMsg.Parent() == KMsvSentEntryIdValue ) &&
+}
-( orgMsg.iMtm == KSenduiMtmSmtpUid ) )
-{
+// ----------------------------------------------------------------------------
-iSmtpService->ChangeServiceIdL( orgMsg );
+// ----------------------------------------------------------------------------
-}
+CFSMailMessage* CIpsPlgSosBasePlugin::CreateReplyMessageL(
-TMsvPartList partList( KMsvMessagePartBody | KMsvMessagePartAttachments );
-CIpsPlgSingleOpWatcher* watcher = CIpsPlgSingleOpWatcher::NewLC(*this);
-//<qmail> changed iSmtpService to pointer
-CIpsPlgCreateForwardMessageOperation* op = CIpsPlgCreateForwardMessageOperation::NewL(
-*iSmtpService,
-*iSession,
-watcher->iStatus,
-partList,
-aMailBoxId,
-orgMsg.Id(),
-aOperationObserver,
-aRequestId );
-//</qmail>
-watcher->SetOperation( op );
-iOperations.AppendL( watcher );
-CleanupStack::Pop( watcher );
-}
-// </qmail>
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-CFSMailMessage* CIpsPlgSosBasePlugin::CreateReplyMessageL(
-const TFSMailMsgId& /*aMailBoxId*/,
-const TFSMailMsgId& /*aOriginalMessageId*/,
-const TBool /*aReplyToAll*/,
-const TDesC& /*aHeaderDescriptor*/ )
-{
-// <qmail> not used any more
-User::Leave(KErrFSMailPluginNotSupported);
-return NULL; // prevents compiler warning
-}
-// <qmail>
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-void CIpsPlgSosBasePlugin::CreateReplyMessageL(
 const TFSMailMsgId& aMailBoxId,
 const TFSMailMsgId& aOriginalMessageId,
 const TBool aReplyToAll,
-MFSMailRequestObserver& aOperationObserver,
+const TDesC& aHeaderDescriptor )
-const TInt aRequestId,
+{
-const TDesC& /* aHeaderDescriptor */ )
+FUNC_LOG;
-{
+CFSMailMessage* msg = iSmtpService->CreateReplySmtpMessageL(
-FUNC_LOG;
+aMailBoxId, aOriginalMessageId, aReplyToAll );
-// asynchronous message creation is started here to enable canceling of the operation
+if ( aHeaderDescriptor != KNullDesC )
-// find orginal message header and check that body is fetched
+{
-TMsvEntry orgMsg;
+// Ignoring trap as it is better to provide something in case of the
-TMsvId service;
+// below fix method fails than nothing.
-User::LeaveIfError(
+TRAP_IGNORE( FixReplyForwardHeaderL(
-iSession->GetEntry( aOriginalMessageId.Id(), service, orgMsg ) );
+msg,
+aMailBoxId,
-if ( orgMsg.Id() ==  KMsvNullIndexEntryIdValue )
+aOriginalMessageId,
-{
+aHeaderDescriptor ) );
-User::Leave(KErrNotFound);
+}
-}
+return msg;
-if ( ( orgMsg.Parent() == KMsvSentEntryIdValue ) &&
+}
-( orgMsg.iMtm == KSenduiMtmSmtpUid ) )
-{
+// ----------------------------------------------------------------------------
-iSmtpService->ChangeServiceIdL( orgMsg );
+// ----------------------------------------------------------------------------
-}
+//
+void CIpsPlgSosBasePlugin::StoreMessageL(
-// partList flags control e.g. what kind of recipient set is created
-TMsvPartList partList = KMsvMessagePartBody | KMsvMessagePartDescription
-| KMsvMessagePartOriginator;
-if( aReplyToAll )
-{
-partList |= KMsvMessagePartRecipient;
-}
-CIpsPlgSingleOpWatcher* watcher = CIpsPlgSingleOpWatcher::NewLC(*this);
-//<qmail> changed iSmtpService to pointer
-CIpsPlgCreateReplyMessageOperation* op = CIpsPlgCreateReplyMessageOperation::NewL(
-*iSmtpService,
-*iSession,
-watcher->iStatus,
-partList,
-aMailBoxId,
-orgMsg.Id(),
-aOperationObserver,
-aRequestId );
-//</qmail>
-watcher->SetOperation( op );
-iOperations.AppendL( watcher );
-CleanupStack::Pop( watcher );
-}
-// </qmail>
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-//
-void CIpsPlgSosBasePlugin::StoreMessageL(
 const TFSMailMsgId& aMailBoxId,
 CFSMailMessage& aMessage )
 	{
 FUNC_LOG;
 TInt status( KErrNone);
 }
 }
 if ( incoming )
 {
-		// <qmail> Cmail change to synchronous call (UpdateMessageFlagsL) ignored,
+// It`s commented because when it`s used heavile cause -16 error
-// <qmail> because it causes emulator & HW to freeze on 10.1
+// For example when user want to mark as read/unread many messages
-CIpsPlgSingleOpWatcher* opW = CIpsPlgSingleOpWatcher::NewLC( *this );
+// Synchronous method solves this issue
-CMsvOperation* op = iMsgMapper->UpdateMessageFlagsAsyncL(
+iMsgMapper->UpdateMessageFlagsL(msgId.Id(), aMessage);
+/*CIpsPlgSingleOpWatcher* opW = CIpsPlgSingleOpWatcher::NewLC( *this );
+CMsvOperation* op = iMsgMapper->UpdateMessageFlagsAsyncL(
 msgId.Id(), aMessage, opW->iStatus );
 if ( op )
 {
 opW->SetOperation( op );
 iOperations.AppendL( opW );
 CleanupStack::Pop( opW );
 }
 else
 {
 CleanupStack::PopAndDestroy( opW );
-}
+}*/
 }
 else
 {
 iSmtpService->StoreMessageL( aMailBoxId, aMessage );
 }
 }
-// <qmail>
-/**
-*
-* @param aMailBoxId Mailbox id.
-* @param aOperationObserver Operation observer.
-* @param aRequestId The request id.
-*/
-void CIpsPlgSosBasePlugin::StoreMessagesL(
-const TFSMailMsgId& /*aMailBox*/,
-RPointerArray<CFSMailMessage> &messages,
-MFSMailRequestObserver& aOperationObserver,
-const TInt aRequestId )
-{
-CIpsPlgSingleOpWatcher* watcher = CIpsPlgSingleOpWatcher::NewL(*this);
-CleanupStack::PushL(watcher);
-CIpsPlgMailStorerOperation* op =
-CIpsPlgMailStorerOperation::NewLC(
-*iSession,
-watcher->iStatus,
-*this,
-messages,
-aOperationObserver,
-aRequestId );
-watcher->SetOperation(op);
-iOperations.AppendL(watcher);
-CleanupStack::Pop( 2, watcher );
-}
-// </qmail>
 // ----------------------------------------------------------------------------
 // CIpsPlgSosBasePlugin::GetMessagesL()
 // ----------------------------------------------------------------------------
 //
 }
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 CFSMailMessagePart* CIpsPlgSosBasePlugin::NewChildPartFromFileL(
-const TFSMailMsgId& /*aMailBoxId*/,
-const TFSMailMsgId& /*aParentFolderId*/,
-const TFSMailMsgId& /*aMessageId*/,
-const TFSMailMsgId& /*aParentPartId*/,
-const TDesC& /*aContentType*/,
-const TDesC& /*aFilePath*/ )
-{
-// <qmail> not used any more
-User::Leave(KErrFSMailPluginNotSupported);
-return NULL; // prevents compiler warning
-}
-// <qmail>
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-void CIpsPlgSosBasePlugin::NewChildPartFromFileL(
 const TFSMailMsgId& aMailBoxId,
 const TFSMailMsgId& /* aParentFolderId */,
 const TFSMailMsgId& aMessageId,
 const TFSMailMsgId& /* aParentPartId */,
 const TDesC& aContentType,
-const TDesC& aFilePath,
+const TDesC& aFilePath )
-MFSMailRequestObserver& aOperationObserver,
+{
-const TInt aRequestId )
+FUNC_LOG;
-{
+CFSMailMessagePart* result ( NULL );
-FUNC_LOG;
+CMsvEntry* cEntry( NULL );
-CIpsPlgSingleOpWatcher* watcher = CIpsPlgSingleOpWatcher::NewLC(*this);
+CImEmailMessage* message( NULL );
+RFile file;
+TInt fileSize( 0 );
+TBool parentToMultipartAlternative( EFalse );
+// Read attachment size
+User::LeaveIfError( file.Open( iSession->FileSession(), aFilePath, EFileShareReadersOnly ) );
+//in rare case that file has disappeared while sending
+//we just won't get the size for it
+file.Size( fileSize );
+file.Close();
+// Take ownership of message entry objects since thanks to
+// "clever" use of active scheduler waits we can re-enter
+// this function leading to crashes if somebody clears the cache
+// while this iteration still needs them
+TakeMessageEntryLC( aMessageId.Id(), cEntry, message );
+// Operation waiter needed to implement synchronous operation
+// on the top of async API
+CIpsPlgOperationWait* waiter = CIpsPlgOperationWait::NewL();
+CleanupStack::PushL( waiter );
+// Initialize CMsvAttachment instance for the attachment creation
+CMsvAttachment* info = CMsvAttachment::NewL( CMsvAttachment::EMsvFile );
+CleanupStack::PushL( info );
+info->SetAttachmentNameL( aFilePath );
+info->SetSize( fileSize );
+// Start attachment creation
+message->AttachmentManager().AddAttachmentL(
+aFilePath, info, waiter->iStatus );
+CleanupStack::Pop( info ); // attachment manager takes ownership
+waiter->Start();
+CleanupStack::PopAndDestroy( waiter );
+// Return message entry objects back to cache
+CleanupStack::Pop( 2 ); // cEntry, message
+ReturnMessageEntry( cEntry, message );
+// Dig out the entry ID of the new attachment (unbelievable that
+// there seems to be no better way to do this)
+message->GetAttachmentsListL( cEntry->Entry().Id( ),
+CImEmailMessage::EAllAttachments, CImEmailMessage::EThisMessageOnly );
+TKeyArrayFix key( 0, ECmpTInt32 );
+CMsvEntrySelection* attachmentIds = message->Selection().CopyLC();
+attachmentIds->Sort( key );
+if ( !attachmentIds->Count() )
+{
+User::Leave( KErrGeneral );
+}
+TMsvId newAttachmentId = (*attachmentIds)[ attachmentIds->Count()-1 ];
+CleanupStack::PopAndDestroy( attachmentIds );
+CMsvEntry* cAtta = iSession->GetEntryL( newAttachmentId );
+CleanupStack::PushL( cAtta );
+// Set filename to iDetails
+TMsvEntry tEntry = cAtta->Entry();
+tEntry.iDetails.Set( aFilePath );
+cAtta->ChangeL( tEntry );
+if( cAtta->HasStoreL() )
+{
+CMsvStore* store = cAtta->EditStoreL();
+CleanupStack::PushL( store );
+CImMimeHeader* mimeHeader = CImMimeHeader::NewLC();
+if( store->IsPresentL( KUidMsgFileMimeHeader ) )
+{
+mimeHeader->RestoreL( *store );
+CDesC8Array& array = mimeHeader->ContentTypeParams();
+array.AppendL( KMethod );
+parentToMultipartAlternative = ETrue;
+if( aContentType.Find( KMimeTextCalRequest ) != KErrNotFound )
+{
+array.AppendL( KRequest );
+}
+else if( aContentType.Find( KMimeTextCalResponse ) != KErrNotFound )
+{
+array.AppendL( KResponse );
+}
+else if( aContentType.Find( KMimeTextCalCancel ) != KErrNotFound )
+{
+array.AppendL( KCancel );
+}
+else
+{
+parentToMultipartAlternative = EFalse;
+}
+mimeHeader->StoreWithoutCommitL( *store );
+store->CommitL();
+}
+CleanupStack::PopAndDestroy( 2, store );
+}
+if( parentToMultipartAlternative &&
+aFilePath.Find( _L(".ics")) != KErrNotFound )
+{
+TMsvEntry tAttaEntry = cAtta->Entry();
+TMsvId id = tAttaEntry.Parent();
+CMsvEntry* cParent = iSession->GetEntryL( id );
+CleanupStack::PushL( cParent );
+TMsvEmailEntry tEntry = cParent->Entry();
+tEntry.SetMessageFolderType( EFolderTypeAlternative );
+cParent->ChangeL( tEntry );
+CleanupStack::PopAndDestroy( cParent );
+}
+CleanupStack::PopAndDestroy( cAtta );
+// Delete the message entries to get all the changes to disk and
+// possible store locks released
+CleanCachedMessageEntries();
+// Create the FS message part object
+result = iMsgMapper->GetMessagePartL( newAttachmentId, aMailBoxId,
+aMessageId );
+return result;
+}
+// ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+CFSMailMessagePart* CIpsPlgSosBasePlugin::NewChildPartFromFileL(
+const TFSMailMsgId& aMailBoxId,
+const TFSMailMsgId& /* aParentFolderId */,
+const TFSMailMsgId& aMessageId,
+const TFSMailMsgId& /* aParentPartId */,
+const TDesC& aContentType,
+RFile& aFile )
+{
+FUNC_LOG;
+// Initialize helper variables
+CFSMailMessagePart* result ( NULL );
+CMsvEntry* cEntry( NULL );
+CImEmailMessage* message( NULL );
+TInt fileSize( 0 );
+TBuf<KMaxFileName> fileName;
+// Take ownership of message entry objects since thanks to
+// "clever" use of active scheduler waits we can re-enter
+// this function leading to crashes if somebody clears the cache
+// while this iteration still needs them
+TakeMessageEntryLC( aMessageId.Id(), cEntry, message );
+// Operation waiter needed to implement synchronous operation
+// on the top of async API
+CIpsPlgOperationWait* waiter = CIpsPlgOperationWait::NewL();
+CleanupStack::PushL( waiter );
+// Initialize CMsvAttachment instance for the attachment creation
+CMsvAttachment* info = CMsvAttachment::NewL( CMsvAttachment::EMsvFile );
+CleanupStack::PushL( info );
+// Read attachment size
+User::LeaveIfError( aFile.Size( fileSize ) );
+info->SetSize( fileSize );
+// Read attachment filename
+User::LeaveIfError( aFile.FullName( fileName ) );
+info->SetAttachmentNameL( fileName );
+message->AttachmentManager().AddAttachmentL( aFile, info, waiter->iStatus );
+CleanupStack::Pop( info ); // attachment manager takes ownership
-CIpsPlgNewChildPartFromFileOperation* op = CIpsPlgNewChildPartFromFileOperation::NewL(
+waiter->Start();
-*iSession,
+CleanupStack::PopAndDestroy( waiter );
-watcher->iStatus,
-aMailBoxId,
+	// Return message entry objects back to cache
-aMessageId,
+	CleanupStack::Pop( 2 ); // cEntry, message
-aContentType,
+	ReturnMessageEntry( cEntry, message );
-aFilePath,
-aOperationObserver,
+// Dig out the entry ID of the new attachment
-aRequestId,
+message->GetAttachmentsListL( cEntry->Entry().Id( ),
-iMsgMapper);
+CImEmailMessage::EAllAttachments, CImEmailMessage::EThisMessageOnly );
-watcher->SetOperation( op );
+TKeyArrayFix key( 0, ECmpTInt32 );
+CMsvEntrySelection* attachmentIds = message->Selection().CopyLC();
-iOperations.AppendL( watcher );
+attachmentIds->Sort( key );
-CleanupStack::Pop( watcher );
+if ( !attachmentIds->Count() )
-}
+{
-// </qmail>
+User::Leave( KErrGeneral );
+}
-// ----------------------------------------------------------------------------
+TMsvId newAttachmentId = (*attachmentIds)[ attachmentIds->Count()-1 ];
-// ----------------------------------------------------------------------------
+CleanupStack::PopAndDestroy( attachmentIds );
-CFSMailMessagePart* CIpsPlgSosBasePlugin::NewChildPartFromFileL(
-const TFSMailMsgId& /*aMailBoxId*/,
+// Meeting request related handling
-const TFSMailMsgId& /*aParentFolderId*/,
+TBool parentToMultipartAlternative( EFalse );
-const TFSMailMsgId& /*aMessageId*/,
+CMsvEntry* cAtta = iSession->GetEntryL( newAttachmentId );
-const TFSMailMsgId& /*aParentPartId*/,
+CleanupStack::PushL( cAtta );
-const TDesC& /*aContentType*/,
-RFile& /*aFile*/ )
+// Set filename to iDetails
-{
+TMsvEntry tEntry = cAtta->Entry();
-// <qmail> not used any more
+tEntry.iDetails.Set( fileName );
-User::Leave(KErrFSMailPluginNotSupported);
+cAtta->ChangeL( tEntry );
-return NULL; // prevents compiler warning
+if( cAtta->HasStoreL() )
+{
+CMsvStore* store = cAtta->EditStoreL();
+CleanupStack::PushL( store );
+CImMimeHeader* mimeHeader = CImMimeHeader::NewLC();
+if( store->IsPresentL( KUidMsgFileMimeHeader ) )
+{
+mimeHeader->RestoreL( *store );
+CDesC8Array& array = mimeHeader->ContentTypeParams();
+array.AppendL( KMethod );
+parentToMultipartAlternative = ETrue;
+if( aContentType.Find( KMimeTextCalRequest ) != KErrNotFound )
+{
+array.AppendL( KRequest );
+}
+else if( aContentType.Find( KMimeTextCalResponse ) != KErrNotFound )
+{
+array.AppendL( KResponse );
+}
+else if( aContentType.Find( KMimeTextCalCancel ) != KErrNotFound )
+{
+array.AppendL( KCancel );
+}
+else
+{
+parentToMultipartAlternative = EFalse;
+}
+mimeHeader->StoreWithoutCommitL( *store );
+store->CommitL();
+}
+CleanupStack::PopAndDestroy( 2, store );
+}
+if( parentToMultipartAlternative && fileName.Find( _L(".ics")) != KErrNotFound )
+{
+TMsvEntry tAttaEntry = cAtta->Entry();
+TMsvId id = tAttaEntry.Parent();
+CMsvEntry* cParent = iSession->GetEntryL( id );
+CleanupStack::PushL( cParent );
+TMsvEmailEntry tEntry = cParent->Entry();
+tEntry.SetMessageFolderType( EFolderTypeAlternative );
+cParent->ChangeL( tEntry );
+CleanupStack::PopAndDestroy( cParent );
+}
+CleanupStack::PopAndDestroy( cAtta );
+// Delete the message entries to get all the changes to disk and
+// possible store locks released
+CleanCachedMessageEntries();
+// Create the FS message part object and return it
+result = iMsgMapper->GetMessagePartL( newAttachmentId, aMailBoxId,
+aMessageId );
+return result;
 }
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 CFSMailMessagePart* CIpsPlgSosBasePlugin::CopyMessageAsChildPartL(
 // Supports currently deletion of attachments and multipart structures
 // which are represented as folders in Symbian store)
 // ----------------------------------------------------------------------------
 //
 void CIpsPlgSosBasePlugin::RemoveChildPartL(
-const TFSMailMsgId& /*aMailBoxId*/,
-const TFSMailMsgId& /*aParentFolderId*/,
-const TFSMailMsgId& /*aMessageId*/,
-const TFSMailMsgId& /*aParentPartId*/,
-const TFSMailMsgId& /*aPartId*/)
-	{
-// <qmail> not used any more
-User::Leave(KErrFSMailPluginNotSupported);
-	}
-// <qmail>
-// ----------------------------------------------------------------------------
-// Supports currently deletion of attachments and multipart structures
-// which are represented as folders in Symbian store)
-// ----------------------------------------------------------------------------
-//
-void CIpsPlgSosBasePlugin::RemoveChildPartL(
 const TFSMailMsgId& /* aMailBoxId */,
 const TFSMailMsgId& /* aParentFolderId */,
 const TFSMailMsgId& aMessageId,
 const TFSMailMsgId& /* aParentPartId */,
-const TFSMailMsgId& aPartId,
+const TFSMailMsgId& aPartId)
-MFSMailRequestObserver& aOperationObserver,
+	{
-const TInt aRequestId )
+FUNC_LOG;
-{
+TInt status( KErrNone );
-FUNC_LOG;
+CMsvEntry* cEntry( NULL );
-CIpsPlgSingleOpWatcher* watcher = CIpsPlgSingleOpWatcher::NewLC(*this);
+TMsvEntry tEntry;
+TMsvId serviceId;
-CIpsPlgRemoveChildPartOperation* op = CIpsPlgRemoveChildPartOperation::NewL(
+status = iSession->GetEntry( aPartId.Id(), serviceId, tEntry );
-*iSession,
-watcher->iStatus,
+if ( ( status == KErrNone ) &&
-aMessageId,
+( tEntry.iType == KUidMsvAttachmentEntry ) )
-aPartId,
+{
-aOperationObserver,
+CImEmailMessage* message( NULL );
-aRequestId);
-watcher->SetOperation( op );
+// We trust that the message ID really refers to a message
-iOperations.AppendL( watcher );
+// Take ownership of message entry objects since thanks to
-CleanupStack::Pop( watcher );
+// "clever" use of active scheduler waits we can re-enter
+// this function leading to crashes if somebody clears the cache
-}
+// while this iteration still needs them
-// </qmail>
+TakeMessageEntryLC( aMessageId.Id(), cEntry, message );
+MMsvAttachmentManager& attachmentMgr( message->AttachmentManager() );
+CIpsPlgOperationWait* waiter = CIpsPlgOperationWait::NewL();
+CleanupStack::PushL( waiter );
+attachmentMgr.RemoveAttachmentL(
+(TMsvAttachmentId) aPartId.Id(), waiter->iStatus );
+waiter->Start();
+CleanupStack::PopAndDestroy( waiter );
+// Return message entry objects to cache
+CleanupStack::Pop( 2 ); // cEntry, message
+ReturnMessageEntry( cEntry, message );
+}
+else if ( ( status == KErrNone ) &&
+( tEntry.iType == KUidMsvFolderEntry ) )
+{
+cEntry = iSession->GetEntryL( tEntry.Parent() );
+CleanupStack::PushL( cEntry );
+cEntry->DeleteL( tEntry.Id() );
+CleanupStack::PopAndDestroy( cEntry );
+}
+	}
 // ----------------------------------------------------------------------------
 // The implementation supoorts the atachment and body parts at the moment.
 // ----------------------------------------------------------------------------
 //
 // ----------------------------------------------------------------------------
 // The implementation bypass CImEmailMessage and its email's attachment
 // manager. Instead, it calls Symbian framework classes directly by
 // accessing the attachment entry.
-// Qmail change: returns file handle for read/write
+// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
+TInt CIpsPlgSosBasePlugin::GetMessagePartFileL(
-TInt CIpsPlgSosBasePlugin::GetMessagePartFileL(
 const TFSMailMsgId& /* aMailBoxId */,
 const TFSMailMsgId& /* aParentFolderId */,
 const TFSMailMsgId& /* aMessageId */,
 const TFSMailMsgId& aMessagePartId,
 RFile& aFileHandle)
 CleanupStack::PushL( cEntry );
 CMsvStore* store = NULL;
 TBool hasStore = cEntry->HasStoreL();
 if ( hasStore )
 {
-//<qmail>
+store = cEntry->ReadStoreL();
-// We need to open store for edit to support multipart/alternative
-// structure: we must have a possibility to modify text/html message part
-//store = cEntry->ReadStoreL();
-store = cEntry->EditStoreL();
-//</qmail>
 }
 if ( !store || !hasStore )
 {
 User::Leave( KErrNotFound );
 MMsvAttachmentManager& attachmentMgr = store->AttachmentManagerL();
 // It is assumed that the attachment file is always in the index 0
 if ( attachmentMgr.AttachmentCount() )
 {
-//<qmail>
+aFileHandle = attachmentMgr.GetAttachmentFileL( 0 );
-// We need to open store for edit to support multipart/alternative
-// structure: we must have a possibility to modify text/html message part
-//aFileHandle = attachmentMgr.GetAttachmentFileL( 0 );
-aFileHandle = attachmentMgr.GetAttachmentFileForWriteL( 0 );
-//</qmail>
 }
 else
 {
 User::Leave( KErrNotFound );
 }
 const TFSMailMsgId& /*aMessageId*/,
 const TFSMailMsgId& aMessagePartId,
 const TDesC& aFilePath)
 	{
 FUNC_LOG;
-//<qmail>
 CMsvEntry* cEntry = iSession->GetEntryL( aMessagePartId.Id() );
 CleanupStack::PushL( cEntry );
 CMsvStore* store = NULL;
 TBool hasStore = cEntry->HasStoreL();
 if ( hasStore )
 {
 User::Leave( KErrNotFound );
 }
 CleanupStack::PopAndDestroy( store );
 CleanupStack::PopAndDestroy( cEntry );
-//</qmail>
 	}
 // ----------------------------------------------------------------------------
 // The method supports only reading of the plain text body currently.
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 void CIpsPlgSosBasePlugin::SetContentL(
 const TDesC& aBuffer,
 const TFSMailMsgId& /* aMailBoxId */,
 const TFSMailMsgId& /* aParentFolderId */,
-const TFSMailMsgId& /* aMessageId */,
+const TFSMailMsgId& aMessageId,
 const TFSMailMsgId& aMessagePartId )
 	{
 FUNC_LOG;
+CMsvEntry* cEntry( NULL );
+CImEmailMessage* message( NULL );
+// Take ownership of message entry objects since thanks to
+// "clever" use of active scheduler waits we can re-enter
+// this function leading to crashes if somebody clears the cache
+// while this iteration still needs them
+TakeMessageEntryLC( aMessageId.Id(), cEntry, message );
-//<qmail> Rewritten in Qmail: CIpsPlgOperationWait is no longer used
+	if ( message )
-// Notice that SetContentL sets only the content of text/plain message part:
+	    {
-// text/html part can be modified directly using GetMessagePartFileL
-	CMsvEntry* cEntry( NULL );
+	    message->GetBodyTextEntryIdL(
-CMsvStore* store = NULL;
+	    		cEntry->Entry().Id(), CImEmailMessage::EThisMessageOnly );
+	    if ( message->Selection().Count() > 0 )
-// following code should fill text/plain content
+	    	{
-cEntry = iSession->GetEntryL( aMessagePartId.Id() );
+	    	TMsvId dummy;
-CleanupStack::PushL( cEntry );
+	    	TMsvEmailEntry newEmailMsg;
-TBool hasStore = cEntry->HasStoreL();
+	    	iSession->GetEntry( aMessageId.Id(), dummy, newEmailMsg );
-if ( hasStore ) {
+	    	TMsvId parent = newEmailMsg.Parent();
-store = cEntry->EditStoreL();
-CleanupStack::PushL(store);
+	    	if ( message->Selection()[0] == aMessagePartId.Id() ||
-CParaFormatLayer* globalParaLayer = CParaFormatLayer::NewL();
+	    		 newEmailMsg.ICalendar() )
-CleanupStack::PushL(globalParaLayer);
+	    		{
-CCharFormatLayer* globalCharLayer = CCharFormatLayer::NewL();
+	    		CIpsPlgOperationWait* wait = CIpsPlgOperationWait::NewLC( );
-CleanupStack::PushL(globalCharLayer);
+	    		CParaFormatLayer* globalParaLayer = CParaFormatLayer::NewL();
-CRichText* text = CRichText::NewL( globalParaLayer, globalCharLayer );
+	    		CleanupStack::PushL(globalParaLayer);
-CleanupStack::PushL( text );
+	    		CCharFormatLayer* globalCharLayer = CCharFormatLayer::NewL();
-// insert text
+	    		CleanupStack::PushL(globalCharLayer);
-text->InsertL(0, aBuffer );
+	    		CRichText* text = CRichText::NewL( globalParaLayer, globalCharLayer );
-store->StoreBodyTextL(*text);
+	    		CleanupStack::PushL( text );
-store->CommitL();
+	    		// insert text
-CleanupStack::PopAndDestroy( 4, store );
+	    		text->InsertL(0, aBuffer );
-}
+	    		// synchronously
-CleanupStack::PopAndDestroy(cEntry);
+	    		message->StoreBodyTextL(
-//</qmail>
+	    				cEntry->Entry().Id(), *text ,wait->iStatus );
+	    		wait->Start();
+	    		CleanupStack::PopAndDestroy( 4, wait );
+	    		}
+	    	}
+	    }
+	// Return message entry objects to cache
+	CleanupStack::Pop( 2 ); // cEntry, message
+	ReturnMessageEntry( cEntry, message );
 	}
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 void CIpsPlgSosBasePlugin::RemovePartContentL(
-const TFSMailMsgId& /*aMailBoxId*/,
+const TFSMailMsgId& /* aMailBoxId */,
-const TFSMailMsgId& /*aParentFolderId*/,
+const TFSMailMsgId& /* aParentFolderId */,
-const TFSMailMsgId& /*aMessageId*/,
+const TFSMailMsgId& /* aMessageId */,
-const RArray<TFSMailMsgId>& /*aPartIds*/ )
+const RArray<TFSMailMsgId>& aPartIds )
 {
-// <qmail>
+TInt count( aPartIds.Count() );
-User::Leave( KErrFSMailPluginNotSupported );
-// </qmail>
+for( TInt i(0); i < count; i++ )
+{
+CMsvEntry* cEntry = iSession->GetEntryL( aPartIds[i].Id() );
+CleanupStack::PushL( cEntry );
+CMsvStore* store = NULL;
+TBool hasStore = cEntry->HasStoreL();
+if ( hasStore )
+{
+store = cEntry->EditStoreL();
+}
+if ( !store || !hasStore )
+{
+User::Leave( KErrNotFound );
+}
+CleanupStack::PushL( store );
+MMsvAttachmentManager& attachmentMgr = store->AttachmentManagerL();
+// It is assumed that the attachment file is always in the index 0
+if ( attachmentMgr.AttachmentCount() )
+{
+// delete attachment file
+CIpsPlgOperationWait* waiter = CIpsPlgOperationWait::NewLC();
+attachmentMgr.RemoveAttachmentL( 0, waiter->iStatus );
+waiter->Start();
+CleanupStack::PopAndDestroy( waiter );
+store->CommitL();
+// clear complete flag
+TMsvEntry tEntry( cEntry->Entry() );
+tEntry.SetComplete( EFalse );
+waiter = CIpsPlgOperationWait::NewLC();
+CMsvOperation* ops = cEntry->ChangeL( tEntry, waiter->iStatus );
+CleanupStack::PushL( ops );
+waiter->Start();
+CleanupStack::PopAndDestroy( 2, waiter );
+}
+else
+{
+User::Leave( KErrNotFound );
+}
+CleanupStack::PopAndDestroy( store );
+CleanupStack::PopAndDestroy( cEntry );
+}
 }
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 void CIpsPlgSosBasePlugin::SetPartContentFromFileL(
 const TFSMailMsgId& /* aMessageId */,
 CFSMailMessagePart& /* aMessagePart */)
 {
 }
-//<qmail>
+// ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-void CIpsPlgSosBasePlugin::StoreMessagePartsL(
-RPointerArray<CFSMailMessagePart>&  aMessageParts,
-MFSMailRequestObserver& aOperationObserver,
-const TInt aRequestId )
-{
-CIpsPlgSingleOpWatcher* watcher = CIpsPlgSingleOpWatcher::NewL(*this);
-CleanupStack::PushL(watcher);
-CIpsPlgMessagePartStorerOperation* op =
-CIpsPlgMessagePartStorerOperation::NewLC(*iSession,
-watcher->iStatus, *this, aMessageParts,
-aOperationObserver, aRequestId);
-watcher->SetOperation(op);
-iOperations.AppendL(watcher);
-CleanupStack::Pop( 2, watcher );
-}
-//<//qmail>
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
 void CIpsPlgSosBasePlugin::UnregisterRequestObserver( TInt /* aRequestId */)
 {
 }
 // ----------------------------------------------------------------------------
 void CIpsPlgSosBasePlugin::SendL(TFSMailMsgId aMessageId )
 	{
 FUNC_LOG;
 	CIpsPlgSingleOpWatcher* watcher = CIpsPlgSingleOpWatcher::NewL(*this);
 	CleanupStack::PushL(watcher);
-// <qmail>
 CIpsPlgSmtpOperation* op = CIpsPlgSmtpOperation::NewLC(
-*iSession, watcher->iStatus );
+*iSession, CActive::EPriorityStandard, watcher->iStatus, ETrue );
-// </qmail>
 op->SetEventHandler(iEventHandler);
 watcher->SetOperation(op);
 CleanupStack::Pop( op ); // op added as member of watcher
 op->StartSendL( aMessageId.Id() );
 iOperations.AppendL(watcher);
 CleanupStack::Pop( watcher );
 	}
+// ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
+void CIpsPlgSosBasePlugin::SendMessageL( CFSMailMessage& aMessage )
-void CIpsPlgSosBasePlugin::SendMessageL( CFSMailMessage& /*aMessage*/ )
+{
-{
+FUNC_LOG;
-FUNC_LOG;
-// <qmail>
-User::Leave( KErrFSMailPluginNotSupported );
-// </qmail>
-}
-// <qmail>
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-void CIpsPlgSosBasePlugin::SendMessageL(
-CFSMailMessage& aMessage,
-MFSMailRequestObserver& aOperationObserver,
-const TInt aRequestId )
-{
-FUNC_LOG;
-// <qmail> Not activated yet
 // is EFSMsgFlag_CalendarMsg enabled,
 // then move send to back ground process
-//if ( aMessage.GetFlags() & EFSMsgFlag_CalendarMsg )
+if ( aMessage.GetFlags() & EFSMsgFlag_CalendarMsg )
-//    {
+{
-//    iEventHandler->SetNewPropertyEvent(
+iEventHandler->SetNewPropertyEvent(
-//            aMessage.GetMessageId().Id(),
+aMessage.GetMessageId().Id(),
-//            KIPSSosSmtpEmptyOutboxNow, KErrNone );
+KIPSSosSmtpEmptyOutboxNow, KErrNone );
-//    }
+}
-//else
+else
-//    {
+{
-CIpsPlgSingleOpWatcher* watcher =
+SendL( aMessage.GetMessageId() );
-CIpsPlgSingleOpWatcher::NewLC(*this);
+}
+}
-// <qmail> priority parameter has been removed
-CIpsPlgSmtpOperation* op = CIpsPlgSmtpOperation::NewL(
-*iSession,
-watcher->iStatus,
-&aOperationObserver,
-aRequestId );
-watcher->SetOperation(op); // ownership is transferred
-op->StartSendL( aMessage.GetMessageId().Id() );
-iOperations.AppendL(watcher);
-CleanupStack::Pop( watcher );
-//    }
-// </qmail>
-}
-// </qmail>
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 TFSProgress CIpsPlgSosBasePlugin::StatusL( TInt aRequestId )
 	{
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 void CIpsPlgSosBasePlugin::DeleteMessagesByUidL(
 const TFSMailMsgId& /*aMailBoxId*/,
 const TFSMailMsgId& /*aFolderId*/,
-	const RArray<TFSMailMsgId>& aMessages )
+const RArray<TFSMailMsgId>& aMessages )
 {
 FUNC_LOG;
 CMsvEntrySelection* sel=new(ELeave) CMsvEntrySelection;
 CleanupStack::PushL(sel);
 TInt count = aMessages.Count();
 TMsvEntry tEntry;
 TMsvId service;
+TMsvEntry parentEntry;
-for(TInt i=0; i<count; i++)
+// simulation of canceling deletion operation
-{
+if ( !count )
-iSession->GetEntry( aMessages[i].Id(), service, tEntry );
+{
-//make sure that only messages get deleted.
+if ( iMsvOpDeleteMessage )
-if( tEntry.iType == KUidMsvMessageEntry )
+{
-{
+iMsvOpDeleteMessage->Cancel();
-			// <qmail>
+}
-sel->AppendL( tEntry.Id() );
-			// </qmail>
-}
-}
-CIpsPlgSingleOpWatcher* watcher = CIpsPlgSingleOpWatcher::NewL( *this );
+if ( iWaitDeleteMessage )
-CleanupStack::PushL( watcher );
+{
-//<qmail>
+iWaitDeleteMessage->Cancel();
-CMsvOperation* op = CIpsPlgDeleteOperation::NewL( *iSession,
+}
-watcher->iStatus, sel );
-//</qmail>
+delete iMsvOpDeleteMessage;
-watcher->SetOperation( op );
+iMsvOpDeleteMessage = NULL;
-iOperations.AppendL( watcher );
+delete iWaitDeleteMessage;
-CleanupStack::Pop( watcher );
+iWaitDeleteMessage = NULL;
-//<qmail>
+delete icEntry;
-CleanupStack::Pop( sel );
+icEntry = NULL;
-//</qmail>
+}
-}
+else
+{
-// <qmail>
+for( TInt i = 0; i < count; i++ )
-// ----------------------------------------------------------------------------
+{
-// ----------------------------------------------------------------------------
+iSession->GetEntry( aMessages[i].Id(), service, tEntry );
-void CIpsPlgSosBasePlugin::DeleteMessagesByUidL(
-const TFSMailMsgId& /*aMailBoxId*/,
+//make sure that only messages get deleted.
-const TFSMailMsgId& /*aFolderId*/,
+if( tEntry.iType == KUidMsvMessageEntry )
-	const RArray<TFSMailMsgId>& aMessages,
+{
-MFSMailRequestObserver& aOperationObserver,
+if(iMsvOpDeleteMessage)
-const TInt aRequestId)
+{
-{
+iMsvOpDeleteMessage->Cancel();
-FUNC_LOG;
+delete iMsvOpDeleteMessage;
-CMsvEntrySelection* sel=new(ELeave) CMsvEntrySelection;
+iMsvOpDeleteMessage = NULL;
-CleanupStack::PushL(sel);
+}
-TInt count = aMessages.Count();
+if ( iWaitDeleteMessage )
-TMsvEntry tEntry;
+{
-TMsvId service;
+iWaitDeleteMessage->Cancel();
+delete iWaitDeleteMessage;
+iWaitDeleteMessage = NULL;
+}
+delete icEntry;
+icEntry = NULL;
+iSession->GetEntry( tEntry.Parent( ), service, parentEntry );
+icEntry = CMsvEntry::NewL(
+*iSession, tEntry.Id(), TMsvSelectionOrdering() );
+// priority slightly increased not to pause the function longer than needed
+iWaitDeleteMessage = CIpsPlgOperationWait::NewL( CActive::EPriorityStandard+1 );
+// Sets bit 32 of iMtmData1, used when msg deleted in Offline
+// and status hasn't updated to server (client entry still exists)
+tEntry.SetLocallyDeleted( ETrue );
+iMsvOpDeleteMessage = icEntry->ChangeL( tEntry,
+iWaitDeleteMessage->iStatus );
+iWaitDeleteMessage->Start();
+sel->AppendL( tEntry.Id() );
+}
+}
+CIpsPlgSingleOpWatcher* watcher = CIpsPlgSingleOpWatcher::NewLC( *this );
+CMsvOperation* op = CIpsPlgDeleteRemote::NewL( *iSession,
+watcher->iStatus, *sel );
+watcher->SetOperation( op );
+// make draft deletion synchronous so that empty drafts are not left after application close
+if ( parentEntry.Id() == KMsvDraftEntryIdValue && count == 1 )
+{
+iWait.Start();
+CleanupStack::PopAndDestroy( watcher );
+}
+else
+{
+iOperations.AppendL( watcher );
+CleanupStack::Pop( watcher );
+}
+}
-for(TInt i=0; i<count; i++)
+CleanupStack::PopAndDestroy( sel );
-{
+}
-iSession->GetEntry( aMessages[i].Id(), service, tEntry );
-//make sure that only messages get deleted.
-if( tEntry.iType == KUidMsvMessageEntry )
-{
-sel->AppendL( tEntry.Id() );
-}
-}
-CIpsPlgSingleOpWatcher* watcher = CIpsPlgSingleOpWatcher::NewL( *this );
-CleanupStack::PushL( watcher );
-CMsvOperation* op = CIpsPlgDeleteOperation::NewL( *iSession,
-watcher->iStatus, sel, aOperationObserver, aRequestId );
-watcher->SetOperation( op );
-iOperations.AppendL( watcher );
-CleanupStack::Pop( watcher );
-CleanupStack::Pop( sel );
-}
-// </qmail>
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 void CIpsPlgSosBasePlugin::SubscribeMailboxEventsL(
 const TFSMailMsgId& aMailboxId,
 MFSMailEventObserver& aObserver)
 {
 FUNC_LOG;
-// <qmail>
+TUint32 key = iSettingsApi->CreateCenRepKeyL(   // faulty CS warning
-TUint32 key(0);
+aMailboxId.Id(),
-// </qmail>
+MtmId(),
+CIpsSetDataStorer::EIpsSetDataLastModifiedH );
 iEventHandler->SubscribeMailboxEventsL( aMailboxId, aObserver, key );
 }
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 TInt CIpsPlgSosBasePlugin::WizardDataAvailableL( )
 {
 FUNC_LOG;
 TInt error = KErrNone;
-// <qmail> iSettingsApi not available in Qmail
+error = iSettingsApi->HandleMailboxCreation( MtmId(), *iSession );
-/*error = iSettingsApi->HandleMailboxCreation( MtmId(), *iSession );
 if ( error == KErrNotSupported )
 {
 // this means that wizard data is not meaned for this plugin (instance)
 // just return KErrNone at the moment
 return KErrNone;
-}*/
+}
-// </qmail>
 return error;
 }
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 }
 // ----------------------------------------------------------------------------
 // method sets authentication popup data
 // ----------------------------------------------------------------------------
-//
+void CIpsPlgSosBasePlugin::SetCredentialsL( const TFSMailMsgId& aMailBoxId,
-void CIpsPlgSosBasePlugin::SetCredentialsL( const TFSMailMsgId& /*aMailBoxId*/,
+	const TDesC& /*aUsername*/, const TDesC& aPassword )
-	const TDesC& /*aUsername*/, const TDesC& /*aPassword*/ )
 	{
-// <qmail> not used; should be removed
+FUNC_LOG;
-//    FUNC_LOG;
+	TBool cancelled = EFalse;
-//	TBool cancelled = EFalse;
-//
+	if ( aPassword.Length() > 0 )
-//	if ( aPassword.Length() > 0 )
+	    {
-//	    {
+	//Set new password and signal (possible) ongoing connect operation
-//    	//Set new password and signal (possible) ongoing connect operation
+	CIpsSetDataApi* api = CIpsSetDataApi::NewL( *iSession );
-//    	//CIpsSetDataApi* api = CIpsSetDataApi::NewL( *iSession );
+CleanupStack::PushL( api );
-//        //CleanupStack::PushL( api );
-//
+CMsvEntry* cEntry = iSession->GetEntryL( aMailBoxId.Id() );
-//        //CMsvEntry* cEntry = iSession->GetEntryL( aMailBoxId.Id() );
+CleanupStack::PushL( cEntry );
-//        //CleanupStack::PushL( cEntry );
-//
+RProcess process;
-//        //api->SetNewPasswordL( *cEntry, aPassword );
+// only email server can set outgoing password
-//
+if ( process.SecureId() == FREESTYLE_FSSERVER_SID )
-//        //CleanupStack::PopAndDestroy( 2, api );//cEntry, api
+{
-//
+if ( !iEventHandler->IncomingPass() )
-//        //now signal through eventhandler that credientials have been set
+{
-//	    }
+CMsvEntry* cTmp = iSession->GetEntryL( cEntry->Entry().iRelatedId );
-//	else
+CleanupStack::PopAndDestroy( 1, cEntry );
-//	    {
+CleanupStack::PushL( cTmp );
-//	    cancelled = ETrue;
+cEntry = cTmp;
-//	    }
+}
-//	iEventHandler->SignalCredientialsSetL( aMailBoxId.Id(), cancelled );
+}
-// </qmail>
+		api->SetNewPasswordL( *cEntry, aPassword );
+CleanupStack::PopAndDestroy( 2, api );//cEntry, api
+//now signal through eventhandler that credientials have been set
+	    }
+	else
+	    {
+	    cancelled = ETrue;
+	    }
+	iEventHandler->SignalCredientialsSetL( aMailBoxId.Id(), cancelled );
 	}
 // ----------------------------------------------------------------------------
 // CIpsPlgSosBasePlugin::GetMessageEntryL( )
 // Checks whether the requested message is already cached. If not, the cached
 void CIpsPlgSosBasePlugin::DeleteAndRemoveOperation(
 const TInt aOpArrayIndex, TInt aCompleteCode )
 {
 FUNC_LOG;
 CIpsPlgSingleOpWatcher* opWatcher = iOperations[aOpArrayIndex];
-// <qmail> removed; does nothing
 // The operations matches, handle it in protocol plugin...if needed.
-//TRAP_IGNORE( HandleOpCompletedL( *opWatcher, aCompleteCode ) );
+TRAP_IGNORE( HandleOpCompletedL( *opWatcher, aCompleteCode ) );
-// </qmail>
 const CIpsPlgBaseOperation* op = opWatcher->BaseOperation();
 TMsvId service = KErrNotFound;
 TUint pluginId = PluginId();
 if ( op && (
 op->IpsOpType() == EIpsOpTypeImap4SyncOp  ||
 op->IpsOpType() == EIpsOpTypePop3SyncOp ||
-op->IpsOpType() == EIpsOpTypeImap4PopulateOp ) )
+op->IpsOpType() == EIpsOpTypeImap4PopulateOp ||
+op->IpsOpType() == EIpsOpTypePop3PopulateOp ) )
 {
 service = op->Service();
 }
 iOperations.Remove( aOpArrayIndex );
 delete opWatcher;
 TPtr hPtr( pckg().iHeader->Des() );
 HBufC* body = HBufC::NewLC(
 textBodyPart->FetchedContentSize() );
 TPtr bPtr( body->Des() );
 origMsgTextBodyPart->GetContentToBufferL( bPtr, 0 );
-HBufC* content = HBufC::NewLC(
+TInt contentLength = hPtr.Length() + bPtr.Length() +
-hPtr.Length() + bPtr.Length() );
+KLineFeed().Length();
-TPtr cPtr( content->Des() );
+HBufC* signatureText = NULL;
+// if signature resolving leaves, ignore it, i.e.,
+// continue without signature adding
+TRAP_IGNORE( signatureText =
+ResolveSignatureTextL( aMailBoxId ) );
+if ( signatureText )
+{
+CleanupStack::PushL( signatureText );
+contentLength += signatureText->Length() +
+KLineFeed().Length();
+}
+HBufC* content = HBufC::NewLC( contentLength );
+TPtr cPtr( content->Des() );
+if ( signatureText )
+{
+cPtr.Append( *signatureText );
+// extra empty line between signature and original txt
+cPtr.Append( KLineFeed );
+}
+cPtr.Append( KLineFeed );
 cPtr.Append( hPtr );
 cPtr.Append( bPtr );
 textBodyPart->SetContent( cPtr );
 textBodyPart->SaveL();
 CleanupStack::PopAndDestroy( content );
+if ( signatureText )
+{
+CleanupStack::PopAndDestroy( signatureText );
+}
 CleanupStack::PopAndDestroy( body );
 CleanupStack::PopAndDestroy( origMsgTextBodyPart );
 }
 CleanupStack::PopAndDestroy( origMsg );
 }
 }
 }
 // ---------------------------------------------------------------------------
 // ---------------------------------------------------------------------------
+HBufC* CIpsPlgSosBasePlugin::ResolveSignatureTextL(
+const TFSMailMsgId& aMailBoxId )
+{
+FUNC_LOG;
+HBufC* signatureText = NULL;
+if ( iSettingsApi && iSession )
+{
+TMsvEntry entry;
+TMsvId serv;
+iSession->GetEntry( aMailBoxId.Id(), serv, entry );
+signatureText = iSettingsApi->SignatureTextL( entry );
+}
+return signatureText;
+}
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
 void CIpsPlgSosBasePlugin::DisconnectL(
 const TFSMailMsgId& aMailBoxId,
 MFSMailRequestObserver& aObserver,
 const TInt aRequestId,
-TBool /*aRemoveAccountAlso*/ )
+TBool aRemoveAccountAlso )
 {
 FUNC_LOG;
 TMsvId service = aMailBoxId.Id();
 TMsvEntry tEntry;
 TMsvId serv;
 iSession->GetEntry( service, serv, tEntry );
+CancelSyncL( aMailBoxId );
 if ( tEntry.Connected() )
 {
 CIpsPlgSingleOpWatcher* watcher = CIpsPlgSingleOpWatcher::NewL(*this);
 CleanupStack::PushL( watcher );
 CMsvEntrySelection* sel=new(ELeave) CMsvEntrySelection;
 CleanupStack::PushL(sel);
 sel->AppendL( service );
-CIpsPlgBaseOperation* op = CIpsPlgDisconnectOp::NewL(
+CIpsPlgBaseOperation* op = CIpsPlgDisconnectOp::NewL( *iSession,
-*iSession,
+watcher->iStatus, service, ActivityTimerL( aMailBoxId ),
-watcher->iStatus,
+aMailBoxId, aObserver, aRequestId,
-service,
+aRemoveAccountAlso );
-ActivityTimerL( aMailBoxId ),
-aMailBoxId,
-&aObserver,
-aRequestId );
 watcher->SetOperation( op );
 CleanupStack::PopAndDestroy( sel );
 iOperations.AppendL( watcher );
 CleanupStack::Pop( watcher );
 void CIpsPlgSosBasePlugin::EmptyOutboxL( const TFSMailMsgId& aMailBoxId )
 {
 FUNC_LOG;
 CIpsPlgSingleOpWatcher* watcher = CIpsPlgSingleOpWatcher::NewL(*this);
 	CleanupStack::PushL(watcher);
-// <qmail>
+CIpsPlgSmtpOperation* op = CIpsPlgSmtpOperation::NewLC(
-CIpsPlgSmtpOperation* op = CIpsPlgSmtpOperation::NewLC( *iSession, watcher->iStatus );
+*iSession, CActive::EPriorityStandard, watcher->iStatus, ETrue );
-// </qmail>
 op->SetEventHandler(iEventHandler);
 watcher->SetOperation(op);
 op->EmptyOutboxFromPendingMessagesL( aMailBoxId.Id() );
 iOperations.AppendL(watcher);
 CleanupStack::Pop( 2, watcher );
 return iSyncStateHandler->ConnOpRunning( aMailBoxId );
 }
 // ---------------------------------------------------------------------------
 // ---------------------------------------------------------------------------
 void CIpsPlgSosBasePlugin::SetMailboxName(
 const TFSMailMsgId& aMailboxId,
-const TDesC& /*aMailboxName*/ )
+const TDesC& aMailboxName )
 {
 FUNC_LOG;
 TMsvEntry tEntry;
 TMsvId service;
 iSession->GetEntry( aMailboxId.Id(), service, tEntry );
-// <qmail> iSettingsApi removed
+TRAP_IGNORE( iSettingsApi->SetMailboxNameL( tEntry, aMailboxName ) );
 }
 // ---------------------------------------------------------------------------
 // ---------------------------------------------------------------------------
 TUid CIpsPlgSosBasePlugin::MtmId() const
 timerCount--;
 j--;
 }
 }
 }
+// ---------------------------------------------------------------------------
-// <qmail> new function
+// finds and returns extension
-// ---------------------------------------------------------------------------
-// ---------------------------------------------------------------------------
-TBool CIpsPlgSosBasePlugin::HasOperations( const TFSMailMsgId& aMailboxId )
-{
-FUNC_LOG;
-TBool ret( EFalse );
-for ( TInt i = 0; i < iOperations.Count(); i++ )
-{
-if( iOperations[i]->BaseOperation() &&
-iOperations[i]->BaseOperation()->FSMailboxId() == aMailboxId )
-{
-ret = ETrue;
-}
-}
-return ret;
-}
-//</Qmail>
-//<Qmail>
-// ---------------------------------------------------------------------------
-// CIpsPlgImap4Plugin::HandleActiveFolderChangeL
 // ---------------------------------------------------------------------------
 //
-void CIpsPlgSosBasePlugin::HandleActiveFolderChangeL(
+CEmailExtension* CIpsPlgSosBasePlugin::ExtensionL( const TUid& aInterfaceUid )
-const TFSMailMsgId& aActiveMailboxId,
+{
-const TFSMailMsgId& aActiveFolderId)
+FUNC_LOG;
-{
-TMsvId service;
-TMsvEntry folder;
-iSession->GetEntry( aActiveFolderId.Id(), service, folder );
+// search for settings extension
+CEmailExtension* extension = CExtendableEmail::ExtensionL( aInterfaceUid );
-//currently, no actions unless this is inbox
+// if not found create settings extension
-//also, if id is '0', it means inbox before first sync...it doesn't really exist yet
+if ( extension == NULL && aInterfaceUid == KEmailSettingExtensionUid)
-if( folder.iDetails.CompareF( KIpsPlgInbox ) == 0 || folder.Id() == 0 ||
+{
-( folder.iMtm == KSenduiMtmPop3Uid ) &&
+extension = new (ELeave) CEmailSettingsExtensionImpl(iSession);
-( folder.iType == KUidMsvServiceEntry ) &&
+CleanupStack::PushL( extension );
-( folder.iServiceId == aActiveFolderId.Id() ) )
+iExtensions.AddL( extension );
-{
+CleanupStack::Pop();
-//folder is inbox
+}
-if ( iSyncStateHandler->GetMailboxIpsState( aActiveMailboxId.Id() )
+return extension;
-== KIpsSosEmailSyncStarted )
+}
-{
-//we won't do anything if sync is already started
-return;
-}
-//check are we in polling mode
-NmIpsSosExtendedSettingsManager* eMgr=
-new NmIpsSosExtendedSettingsManager(aActiveMailboxId.Id());
-QVariant value;
-bool ok = eMgr->readSetting(IpsServices::ReceptionActiveProfile, value);
-delete eMgr;
-if ( ok )
-{
-TInt profile = value.toInt();
-if ( profile != IpsServices::EmailSyncProfileManualFetch )
-{
-// let's sync
-GoOnlineL(aActiveMailboxId);
-}
-}
-}
-}
-// </qmail>

branch	RCL_3
changeset 64	3533d4323edc
parent 63	d189ee25cf9d
child 70	968773a0b6ef