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

equal deleted inserted replaced

-:dcf0eedfc1a3
+:d189ee25cf9d
 *
 */
 #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;
-_LIT( KMimeTextCalRequest,  "text/calendar; method=REQUEST;" );
+// <qmail> remove unused literals
-_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 );
-iSettingsApi = CIpsSetDataApi::NewL( *iSession );
+	// <qmail> iSettingsApi removed
-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 );
 }
-}
-// make draft deletion synchronous so that empty drafts are not left after application close.
+// <qmail> iWait removed
-if ( iWait.IsStarted() )
-{
-iWait.AsyncStop();
 }
 }
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 iSession->GetEntry( aMailBoxId.Id(), service, tEntry );
 if ( tEntry.Connected() )
 {
 status = EFSMailBoxOnline;
 }
-		else
+else if ( ConnOpRunning( aMailBoxId ) )
+{
+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 ) );
-iSettingsApi->GetMailboxAddressL( tEntry, address );
+// <qmail>
+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 );
 }
-// Create connection to Always Online
+// <qmail> RAlwaysOnlineClientSession - related code removed
-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() );
-CancelAllOnlineOperations( aMailBoxId );
+// <qmail> CancelAllOnlineOperations function call removed
 iSession->GetEntry( aMailBoxId.Id(), service, tEntry );
 if ( tEntry.Connected() )
 {
 DisconnectL( aMailBoxId, aOperationObserver, aRequestId, ETrue );
 }
 }
 }
 else
 {
-iSettingsApi->RemoveAccountL( tEntry, *iSession );
+// <qmail> iSettingsApi removed
 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() );
-TMsvEntry tEntry;
+CleanupStack::PushL( mboxEntry );
-TMsvId serviceId;
-TInt status = iSession->GetEntry( aMailBoxId.Id(), serviceId, tEntry );
+// <qmail> iSettingsApi removed, iBrandingId removed
+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() )
 {
-CIpsPlgOperationWait* wait = CIpsPlgOperationWait::NewLC();
+// <qmail> remove activeschedulerwait
+TMsvLocalOperationProgress progress;
 if( !aSourceFolderId.IsNullId() )
 {
 CMsvEntry* cEntry = iSession->GetEntryL( aSourceFolderId.Id() );
 CleanupStack::PushL( cEntry );
-cEntry->MoveL(
+cEntry->MoveL( *sel, aDestinationFolderId.Id(), progress );
-*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(
+msgEntry->CopyL( *sel, aDestinationFolderId.Id(), progress );
-*sel,
+}
-aDestinationFolderId.Id(),//KMsvDraftEntryIdValue
+User::LeaveIfError( progress.iError );
-wait->iStatus );
+// </qmail>
-}
-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 = iSettingsApi->GetLastSyncStatusL( tEntry );
+TInt state(0);
+// </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*/ )
 	{
-FUNC_LOG;
+// <qmail> not used any more
-CFSMailMessage* msg = iSmtpService->CreateNewSmtpMessageL( aMailBoxId );
+User::Leave(KErrFSMailPluginNotSupported);
-	return msg;
+return NULL; // prevents compiler warning
 	}
+// <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,
-const TDesC& aHeaderDescriptor )
+MFSMailRequestObserver& aOperationObserver,
-{
+const TInt aRequestId,
-FUNC_LOG;
+const TDesC& /*aHeaderDescriptor*/ )
-CFSMailMessage* msg = iSmtpService->CreateForwardSmtpMessageL(
+{
-aMailBoxId, aOriginalMessageId );
+FUNC_LOG;
+// asynchronous message creation is started here to enable canceling of the operation
-if ( aHeaderDescriptor != KNullDesC )
-{
+// 1. part of function checs that body text and all
-// Ignoring trap as it is better to provide something in case of the
+// attachments are fetched
-// below fix method fails than nothing.
+TMsvEntry orgMsg;
-TRAP_IGNORE( FixReplyForwardHeaderL(
+TMsvId service;
-msg,
+User::LeaveIfError( iSession->GetEntry(
-aMailBoxId,
+aOriginalMessageId.Id(), service, orgMsg ) );
-aOriginalMessageId,
-aHeaderDescriptor ) );
+if ( orgMsg.Id() ==  KMsvNullIndexEntryIdValue )
-}
+{
+User::Leave(KErrNotFound);
-return msg;
+}
-}
+if ( ( orgMsg.Parent() == KMsvSentEntryIdValue ) &&
-// ----------------------------------------------------------------------------
+( orgMsg.iMtm == KSenduiMtmSmtpUid ) )
-// ----------------------------------------------------------------------------
+{
-CFSMailMessage* CIpsPlgSosBasePlugin::CreateReplyMessageL(
+iSmtpService->ChangeServiceIdL( orgMsg );
+}
+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,
-const TDesC& aHeaderDescriptor )
+MFSMailRequestObserver& aOperationObserver,
-{
+const TInt aRequestId,
-FUNC_LOG;
+const TDesC& /* aHeaderDescriptor */ )
-CFSMailMessage* msg = iSmtpService->CreateReplySmtpMessageL(
+{
-aMailBoxId, aOriginalMessageId, aReplyToAll );
+FUNC_LOG;
+// 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
-// Ignoring trap as it is better to provide something in case of the
+TMsvEntry orgMsg;
-// below fix method fails than nothing.
+TMsvId service;
-TRAP_IGNORE( FixReplyForwardHeaderL(
+User::LeaveIfError(
-msg,
+iSession->GetEntry( aOriginalMessageId.Id(), service, orgMsg ) );
-aMailBoxId,
-aOriginalMessageId,
+if ( orgMsg.Id() ==  KMsvNullIndexEntryIdValue )
-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 )
 {
-// It`s commented because when it`s used heavile cause -16 error
+		// <qmail> Cmail change to synchronous call (UpdateMessageFlagsL) ignored,
-// For example when user want to mark as read/unread many messages
+// <qmail> because it causes emulator & HW to freeze on 10.1
-// Synchronous method solves this issue
+CIpsPlgSingleOpWatcher* opW = CIpsPlgSingleOpWatcher::NewLC( *this );
-iMsgMapper->UpdateMessageFlagsL(msgId.Id(), aMessage);
+CMsvOperation* op = iMsgMapper->UpdateMessageFlagsAsyncL(
-/*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,
-FUNC_LOG;
+const TInt aRequestId )
-CFSMailMessagePart* result ( NULL );
+{
-CMsvEntry* cEntry( NULL );
+FUNC_LOG;
-CImEmailMessage* message( NULL );
+CIpsPlgSingleOpWatcher* watcher = CIpsPlgSingleOpWatcher::NewLC(*this);
-RFile file;
-TInt fileSize( 0 );
+CIpsPlgNewChildPartFromFileOperation* op = CIpsPlgNewChildPartFromFileOperation::NewL(
-TBool parentToMultipartAlternative( EFalse );
+*iSession,
+watcher->iStatus,
-// Read attachment size
+aMailBoxId,
-User::LeaveIfError( file.Open( iSession->FileSession(), aFilePath, EFileShareReadersOnly ) );
+aMessageId,
+aContentType,
-//in rare case that file has disappeared while sending
+aFilePath,
-//we just won't get the size for it
+aOperationObserver,
-file.Size( fileSize );
+aRequestId,
-file.Close();
+iMsgMapper);
+watcher->SetOperation( op );
-// Take ownership of message entry objects since thanks to
-// "clever" use of active scheduler waits we can re-enter
+iOperations.AppendL( watcher );
-// this function leading to crashes if somebody clears the cache
+CleanupStack::Pop( watcher );
-// while this iteration still needs them
+}
-TakeMessageEntryLC( aMessageId.Id(), cEntry, message );
+// </qmail>
-// 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& /*aMailBoxId*/,
-const TFSMailMsgId& /* aParentFolderId */,
+const TFSMailMsgId& /*aParentFolderId*/,
-const TFSMailMsgId& aMessageId,
+const TFSMailMsgId& /*aMessageId*/,
-const TFSMailMsgId& /* aParentPartId */,
+const TFSMailMsgId& /*aParentPartId*/,
-const TDesC& aContentType,
+const TDesC& /*aContentType*/,
-RFile& aFile )
+RFile& /*aFile*/ )
 {
-FUNC_LOG;
+// <qmail> not used any more
+User::Leave(KErrFSMailPluginNotSupported);
-// Initialize helper variables
+return NULL; // prevents compiler warning
-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
-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
-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 );
-// Meeting request related handling
-TBool parentToMultipartAlternative( EFalse );
-CMsvEntry* cAtta = iSession->GetEntryL( newAttachmentId );
-CleanupStack::PushL( cAtta );
-// Set filename to iDetails
-TMsvEntry tEntry = cAtta->Entry();
-tEntry.iDetails.Set( fileName );
-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 && 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,
-FUNC_LOG;
+const TInt aRequestId )
-TInt status( KErrNone );
+{
-CMsvEntry* cEntry( NULL );
+FUNC_LOG;
-TMsvEntry tEntry;
+CIpsPlgSingleOpWatcher* watcher = CIpsPlgSingleOpWatcher::NewLC(*this);
-TMsvId serviceId;
-status = iSession->GetEntry( aPartId.Id(), serviceId, tEntry );
+CIpsPlgRemoveChildPartOperation* op = CIpsPlgRemoveChildPartOperation::NewL(
+*iSession,
-if ( ( status == KErrNone ) &&
+watcher->iStatus,
-( tEntry.iType == KUidMsvAttachmentEntry ) )
+aMessageId,
-{
+aPartId,
-CImEmailMessage* message( NULL );
+aOperationObserver,
+aRequestId);
-// We trust that the message ID really refers to a message
+watcher->SetOperation( op );
-// Take ownership of message entry objects since thanks to
+iOperations.AppendL( watcher );
-// "clever" use of active scheduler waits we can re-enter
+CleanupStack::Pop( watcher );
-// this function leading to crashes if somebody clears the cache
-// while this iteration still needs them
+}
-TakeMessageEntryLC( aMessageId.Id(), cEntry, message );
+// </qmail>
-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 )
 {
-store = cEntry->ReadStoreL();
+//<qmail>
+// 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() )
 {
-aFileHandle = attachmentMgr.GetAttachmentFileL( 0 );
+//<qmail>
+// 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 );
+//<qmail> Rewritten in Qmail: CIpsPlgOperationWait is no longer used
+// Notice that SetContentL sets only the content of text/plain message part:
-// Take ownership of message entry objects since thanks to
+// text/html part can be modified directly using GetMessagePartFileL
-// "clever" use of active scheduler waits we can re-enter
+	CMsvEntry* cEntry( NULL );
-// this function leading to crashes if somebody clears the cache
+CMsvStore* store = NULL;
-// while this iteration still needs them
-TakeMessageEntryLC( aMessageId.Id(), cEntry, message );
+// following code should fill text/plain content
+cEntry = iSession->GetEntryL( aMessagePartId.Id() );
-	if ( message )
+CleanupStack::PushL( cEntry );
-	    {
+TBool hasStore = cEntry->HasStoreL();
+if ( hasStore ) {
-	    message->GetBodyTextEntryIdL(
+store = cEntry->EditStoreL();
-	    		cEntry->Entry().Id(), CImEmailMessage::EThisMessageOnly );
+CleanupStack::PushL(store);
-	    if ( message->Selection().Count() > 0 )
+CParaFormatLayer* globalParaLayer = CParaFormatLayer::NewL();
-	    	{
+CleanupStack::PushL(globalParaLayer);
-	    	TMsvId dummy;
+CCharFormatLayer* globalCharLayer = CCharFormatLayer::NewL();
-	    	TMsvEmailEntry newEmailMsg;
+CleanupStack::PushL(globalCharLayer);
-	    	iSession->GetEntry( aMessageId.Id(), dummy, newEmailMsg );
+CRichText* text = CRichText::NewL( globalParaLayer, globalCharLayer );
-	    	TMsvId parent = newEmailMsg.Parent();
+CleanupStack::PushL( text );
+// insert text
-	    	if ( message->Selection()[0] == aMessagePartId.Id() ||
+text->InsertL(0, aBuffer );
-	    		 newEmailMsg.ICalendar() )
+store->StoreBodyTextL(*text);
-	    		{
+store->CommitL();
-	    		CIpsPlgOperationWait* wait = CIpsPlgOperationWait::NewLC( );
+CleanupStack::PopAndDestroy( 4, store );
-	    		CParaFormatLayer* globalParaLayer = CParaFormatLayer::NewL();
+}
-	    		CleanupStack::PushL(globalParaLayer);
+CleanupStack::PopAndDestroy(cEntry);
-	    		CCharFormatLayer* globalCharLayer = CCharFormatLayer::NewL();
+//</qmail>
-	    		CleanupStack::PushL(globalCharLayer);
-	    		CRichText* text = CRichText::NewL( globalParaLayer, globalCharLayer );
-	    		CleanupStack::PushL( text );
-	    		// insert text
-	    		text->InsertL(0, aBuffer );
-	    		// synchronously
-	    		message->StoreBodyTextL(
-	    				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*/ )
 {
-TInt count( aPartIds.Count() );
+// <qmail>
+User::Leave( KErrFSMailPluginNotSupported );
-for( TInt i(0); i < count; i++ )
+// </qmail>
-{
-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, CActive::EPriorityStandard, watcher->iStatus, ETrue );
+*iSession, watcher->iStatus );
+// </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
-{
+//    {
-SendL( aMessage.GetMessageId() );
+CIpsPlgSingleOpWatcher* watcher =
-}
+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
+iSession->GetEntry( aMessages[i].Id(), service, tEntry );
-if ( !count )
+//make sure that only messages get deleted.
-{
+if( tEntry.iType == KUidMsvMessageEntry )
-if ( iMsvOpDeleteMessage )
+{
-{
+			// <qmail>
-iMsvOpDeleteMessage->Cancel();
+sel->AppendL( tEntry.Id() );
-}
+			// </qmail>
+}
+}
-if ( iWaitDeleteMessage )
+CIpsPlgSingleOpWatcher* watcher = CIpsPlgSingleOpWatcher::NewL( *this );
-{
+CleanupStack::PushL( watcher );
-iWaitDeleteMessage->Cancel();
+//<qmail>
-}
+CMsvOperation* op = CIpsPlgDeleteOperation::NewL( *iSession,
+watcher->iStatus, sel );
+//</qmail>
+watcher->SetOperation( op );
+iOperations.AppendL( watcher );
+CleanupStack::Pop( watcher );
+//<qmail>
+CleanupStack::Pop( sel );
+//</qmail>
+}
+// <qmail>
+// ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+void CIpsPlgSosBasePlugin::DeleteMessagesByUidL(
+const TFSMailMsgId& /*aMailBoxId*/,
+const TFSMailMsgId& /*aFolderId*/,
+	const RArray<TFSMailMsgId>& aMessages,
+MFSMailRequestObserver& aOperationObserver,
+const TInt aRequestId)
+{
+FUNC_LOG;
+CMsvEntrySelection* sel=new(ELeave) CMsvEntrySelection;
+CleanupStack::PushL(sel);
+TInt count = aMessages.Count();
+TMsvEntry tEntry;
+TMsvId service;
+for(TInt i=0; i<count; i++)
+{
+iSession->GetEntry( aMessages[i].Id(), service, tEntry );
+//make sure that only messages get deleted.
+if( tEntry.iType == KUidMsvMessageEntry )
+{
+sel->AppendL( tEntry.Id() );
+}
+}
-delete iMsvOpDeleteMessage;
+CIpsPlgSingleOpWatcher* watcher = CIpsPlgSingleOpWatcher::NewL( *this );
-iMsvOpDeleteMessage = NULL;
+CleanupStack::PushL( watcher );
-delete iWaitDeleteMessage;
+CMsvOperation* op = CIpsPlgDeleteOperation::NewL( *iSession,
-iWaitDeleteMessage = NULL;
+watcher->iStatus, sel, aOperationObserver, aRequestId );
-delete icEntry;
+watcher->SetOperation( op );
-icEntry = NULL;
+iOperations.AppendL( watcher );
-}
+CleanupStack::Pop( watcher );
-else
+CleanupStack::Pop( sel );
-{
+}
-for( TInt i = 0; i < count; i++ )
+// </qmail>
-{
-iSession->GetEntry( aMessages[i].Id(), service, tEntry );
-//make sure that only messages get deleted.
-if( tEntry.iType == KUidMsvMessageEntry )
-{
-if(iMsvOpDeleteMessage)
-{
-iMsvOpDeleteMessage->Cancel();
-delete iMsvOpDeleteMessage;
-iMsvOpDeleteMessage = NULL;
-}
-if ( iWaitDeleteMessage )
-{
-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 );
-}
-}
-CleanupStack::PopAndDestroy( sel );
-}
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 void CIpsPlgSosBasePlugin::SubscribeMailboxEventsL(
 const TFSMailMsgId& aMailboxId,
 MFSMailEventObserver& aObserver)
 {
 FUNC_LOG;
-TUint32 key = iSettingsApi->CreateCenRepKeyL(   // faulty CS warning
+// <qmail>
-aMailboxId.Id(),
+TUint32 key(0);
-MtmId(),
+// </qmail>
-CIpsSetDataStorer::EIpsSetDataLastModifiedH );
 iEventHandler->SubscribeMailboxEventsL( aMailboxId, aObserver, key );
 }
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 TInt CIpsPlgSosBasePlugin::WizardDataAvailableL( )
 {
 FUNC_LOG;
 TInt error = KErrNone;
-error = iSettingsApi->HandleMailboxCreation( MtmId(), *iSession );
+// <qmail> iSettingsApi not available in Qmail
+/*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,
+//
-	const TDesC& /*aUsername*/, const TDesC& aPassword )
+void CIpsPlgSosBasePlugin::SetCredentialsL( const TFSMailMsgId& /*aMailBoxId*/,
-	{
+	const TDesC& /*aUsername*/, const TDesC& /*aPassword*/ )
-FUNC_LOG;
+	{
-	TBool cancelled = EFalse;
+// <qmail> not used; should be removed
+//    FUNC_LOG;
-	if ( aPassword.Length() > 0 )
+//	TBool cancelled = EFalse;
-	    {
+//
-	//Set new password and signal (possible) ongoing connect operation
+//	if ( aPassword.Length() > 0 )
-	CIpsSetDataApi* api = CIpsSetDataApi::NewL( *iSession );
+//	    {
-CleanupStack::PushL( api );
+//    	//Set new password and signal (possible) ongoing connect operation
+//    	//CIpsSetDataApi* api = CIpsSetDataApi::NewL( *iSession );
-CMsvEntry* cEntry = iSession->GetEntryL( aMailBoxId.Id() );
+//        //CleanupStack::PushL( api );
-CleanupStack::PushL( cEntry );
+//
+//        //CMsvEntry* cEntry = iSession->GetEntryL( aMailBoxId.Id() );
-RProcess process;
+//        //CleanupStack::PushL( cEntry );
-// only email server can set outgoing password
+//
-if ( process.SecureId() == FREESTYLE_FSSERVER_SID )
+//        //api->SetNewPasswordL( *cEntry, aPassword );
-{
+//
-if ( !iEventHandler->IncomingPass() )
+//        //CleanupStack::PopAndDestroy( 2, api );//cEntry, api
-{
+//
-CMsvEntry* cTmp = iSession->GetEntryL( cEntry->Entry().iRelatedId );
+//        //now signal through eventhandler that credientials have been set
-CleanupStack::PopAndDestroy( 1, cEntry );
+//	    }
-CleanupStack::PushL( cTmp );
+//	else
-cEntry = cTmp;
+//	    {
-}
+//	    cancelled = ETrue;
-}
+//	    }
+//	iEventHandler->SignalCredientialsSetL( aMailBoxId.Id(), cancelled );
-		api->SetNewPasswordL( *cEntry, aPassword );
+// </qmail>
-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 );
-TInt contentLength = hPtr.Length() + bPtr.Length() +
+HBufC* content = HBufC::NewLC(
-KLineFeed().Length();
+hPtr.Length() + bPtr.Length() );
-HBufC* signatureText = NULL;
+TPtr cPtr( content->Des() );
-// 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( *iSession,
+CIpsPlgBaseOperation* op = CIpsPlgDisconnectOp::NewL(
-watcher->iStatus, service, ActivityTimerL( aMailBoxId ),
+*iSession,
-aMailBoxId, aObserver, aRequestId,
+watcher->iStatus,
-aRemoveAccountAlso );
+service,
+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);
-CIpsPlgSmtpOperation* op = CIpsPlgSmtpOperation::NewLC(
+// <qmail>
-*iSession, CActive::EPriorityStandard, watcher->iStatus, ETrue );
+CIpsPlgSmtpOperation* op = CIpsPlgSmtpOperation::NewLC( *iSession, watcher->iStatus );
+// </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 );
-TRAP_IGNORE( iSettingsApi->SetMailboxNameL( tEntry, aMailboxName ) );
+// <qmail> iSettingsApi removed
 }
 // ---------------------------------------------------------------------------
 // ---------------------------------------------------------------------------
 TUid CIpsPlgSosBasePlugin::MtmId() const
 timerCount--;
 j--;
 }
 }
 }
-// ---------------------------------------------------------------------------
-// finds and returns extension
+// <qmail> new function
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+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
 // ---------------------------------------------------------------------------
 //
-CEmailExtension* CIpsPlgSosBasePlugin::ExtensionL( const TUid& aInterfaceUid )
+void CIpsPlgSosBasePlugin::HandleActiveFolderChangeL(
-{
+const TFSMailMsgId& aActiveMailboxId,
-FUNC_LOG;
+const TFSMailMsgId& aActiveFolderId)
+{
-// search for settings extension
+TMsvId service;
-CEmailExtension* extension = CExtendableEmail::ExtensionL( aInterfaceUid );
+TMsvEntry folder;
+iSession->GetEntry( aActiveFolderId.Id(), service, folder );
-// if not found create settings extension
-if ( extension == NULL && aInterfaceUid == KEmailSettingExtensionUid)
-{
+//currently, no actions unless this is inbox
-extension = new (ELeave) CEmailSettingsExtensionImpl(iSession);
+//also, if id is '0', it means inbox before first sync...it doesn't really exist yet
-CleanupStack::PushL( extension );
+if( folder.iDetails.CompareF( KIpsPlgInbox ) == 0 || folder.Id() == 0 ||
-iExtensions.AddL( extension );
+( folder.iMtm == KSenduiMtmPop3Uid ) &&
-CleanupStack::Pop();
+( folder.iType == KUidMsvServiceEntry ) &&
-}
+( folder.iServiceId == aActiveFolderId.Id() ) )
-return extension;
+{
-}
+//folder is inbox
+if ( iSyncStateHandler->GetMailboxIpsState( aActiveMailboxId.Id() )
+== 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 24	d189ee25cf9d
parent 23	dcf0eedfc1a3
child 25	3533d4323edc