1 // Copyright (c) 1998-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // IMAP4MTM.CPP

    15 // 

    16 //

    17 

    18 #include "IMPCMTM.H"

    19 #include "MIUT_ERR.H"

    20 

    21 #include <barsc.h>		//RResourceFile

    22 #include <barsread.h>

    23 #include <bautils.h>

    24 #include <txtrich.h>

    25 #include <msvutils.h>

    26 #include <cemailaccounts.h>

    27 

    28 #include "MIUTMSG.H"	//CImEmailOperation

    29 #include "CONSYNC.H"

    30 #include <imcm.rsg>

    31 #include "IMCMUTIL.H"

    32 #include <e32base.h>

    33 #include <autosend.h>

    34 #ifdef SYMBIAN_ENABLE_SPLIT_HEADERS  

    35 #include "miut_errconsts.h"

    36 #include "cimmessagepart.h"

    37 #include "timrfc822datefield.h"

    38 #include <mtmuidsdef.hrh>

    39 #endif

    40 

    41 #include <msvenhancesearchsortutil.h>

    42 

    43 _LIT(KMsvAutoSendExe, "Autosend.exe");

    44 const TUid KMsvAutoSendExeUid = {0x1000A402}; //268477442

    45 

    46 #define TODO//@

    47 

    48 

    49 //

    50 //  Session Observer for the Imap4 Client MTM  

    51 class CImap4ClientSessionObserver : public CBase , public MMsvSessionObserver

    52 	{

    53 public:

    54 	void HandleSessionEventL(TMsvSessionEvent aEvent, TAny* aArg1, TAny* aArg2, TAny* aArg3);

    55 	};

    56 

    57 void CImap4ClientSessionObserver::HandleSessionEventL(TMsvSessionEvent /*aEvent*/, TAny* /*aArg1*/, TAny* /*aArg2*/, TAny* /*aArg3*/)

    58 	{

    59 	}

    60 

    61 

    62 //

    63 //  CImap4ClientMtm methods.

    64 

    65 

    66 /**

    67 @internalTechnology

    68 */

    69 /** IMAP4 client MTM factory function.

    70 

    71 This function is not called directly by messaging clients. To create a client MTM

    72 object, use CClientMtmRegistry::NewMtmL().

    73 

    74 @param aRegisteredMtmDll MTM registry information 

    75 @param aSession Message server session

    76 @return New IMAP4 client MTM object

    77 @see CClientMtmRegistry::NewMtmL()

    78 */

    79 EXPORT_C CImap4ClientMtm* CImap4ClientMtm::NewL(CRegisteredMtmDll& aRegisteredMtmDll, CMsvSession& aSession)

    80 	{

    81 	CImap4ClientMtm* self = new (ELeave) CImap4ClientMtm(aRegisteredMtmDll, aSession);

    82 	CleanupStack::PushL(self);

    83 	self->ConstructL();

    84 	CleanupStack::Pop();

    85 	return self;

    86 	}

    87 

    88 CImap4ClientMtm::CImap4ClientMtm(CRegisteredMtmDll& aRegisteredMtmDll, CMsvSession& aSession)

    89 : CBaseMtm(aRegisteredMtmDll, aSession)

    90 	{

    91 	}

    92 

    93 void CImap4ClientMtm::ConstructL()

    94 	{

    95 	iImap4ClientSessionObserver = new (ELeave) CImap4ClientSessionObserver;

    96 	iHeader = CImHeader::NewLC();

    97 	CleanupStack::Pop();	// iHeader

    98 

    99 	//open the resource file

   100 	RFs fs;

   101 	User::LeaveIfError(fs.Connect());

   102 	CleanupClosePushL(fs);

   103 	//	Need to search for IMCM resource file on all drives -

   104 	//	it won't necessarily be on the same one as IMPC.DLL

   105 	//

   106 	TFileName fileName(KImEngineResourceFile);

   107 	MsvUtils::AddPathAndExtensionToResFileL(fileName);

   108 	BaflUtils::NearestLanguageFile( fs, fileName );		//	change to appropriate language

   109 

   110 	RResourceFile resourceFile;

   111 	resourceFile.OpenL(fs,fileName);

   112 	CleanupClosePushL(resourceFile);

   113 	HBufC8* buf = resourceFile.AllocReadLC(EMAIL_ADDRESS_FORMATTING_STRING);

   114 	TResourceReader reader;

   115 	reader.SetBuffer(buf);

   116 	iEmailAddressFormatString = (reader.ReadTPtrC()).AllocL();

   117 	CleanupStack::PopAndDestroy(3);// resourceFile (Close resourceFile), fs

   118 	}

   119 

   120 CImap4ClientMtm::~CImap4ClientMtm()

   121 /** Destructor. */

   122 	{

   123 	delete iImap4ClientSessionObserver;

   124 	delete iEmailAddressFormatString;

   125 	delete iHeader;

   126 	delete iMsvEntrySelection;

   127 	delete iImIMAP4GetMail;

   128 	delete iImEmailOperation;

   129 	}

   130 

   131 void CImap4ClientMtm::SaveMessageL()

   132 /** Empty implementation of base class function. 

   133 

   134 To edit an IMAP message, use CImEmailMessage.

   135 */

   136 	{

   137 	}

   138 

   139 EXPORT_C void CImap4ClientMtm::StoreSettingsL()

   140 /** If the current context of the client MTM is an IMAP4 service, stores settings 

   141 in the Central Repository. 

   142 

   143 @panic IMCM 33 MTM has no current context (debug builds only)

   144 @panic IMCM 44 Current context is not a service (debug builds only)

   145 */

   146 	{

   147 	__ASSERT_DEBUG(iMsvEntry!=NULL,gPanic(EImpcNoCMsvEntrySet));

   148 

   149 	// check that current context is a service entry

   150 	__ASSERT_DEBUG(iMsvEntry->Entry().iType==KUidMsvServiceEntry,gPanic(EImpcMTMNotAServiceEntry));

   151 

   152 	CEmailAccounts* account = CEmailAccounts::NewLC();

   153   	TImapAccount id;

   154 	account->GetImapAccountL(iMsvEntry->Entry().Id(), id);

   155 	account->SaveImapSettingsL(id, iImImap4Settings);

   156 	CleanupStack::PopAndDestroy(account);    

   157 	}

   158 

   159 void CImap4ClientMtm::LoadMessageL()

   160 /** Loads the cache with the message data for the current message context. 

   161 

   162 The current context should be an IMAP service or a message. 

   163 If the current context is an IMAP service, then the function loads the service settings

   164 from the Central Repository. This is the same behaviour as RestoreSettingsL().

   165 */

   166 	{

   167 	Body().Reset();

   168 	iHeader->Reset();

   169 	switch (iMsvEntry->Entry().iType.iUid)

   170 		{

   171 		case KUidMsvServiceEntryValue:

   172 			RestoreSettingsL();

   173 			break;

   174 		case KUidMsvMessageEntryValue:

   175 			{//restore header

   176 			if (!iMsvEntry->HasStoreL())

   177 				return;

   178 		

   179 				

   180 			// Get a reference to TMsvEnhanceSearchSortUtil  instance set by CMsvSearchsortOpOnHeaderBody class

   181 			// If advanced search and sort is being performed than do not load the message header and body.

   182 			// These are loaded when the search criteria is known in DoFindL()

   183 			// For API's other than CMsvSearchsortOpOnHeaderBody-> FindInHeaderBodyL(), a call to LoadMessageL()

   184 			// loads the body and the header.

   185 			TMsvEnhanceSearchSortUtil* searchsortutil = (TMsvEnhanceSearchSortUtil*)(GetExtensionData());

   186 			

   187 			if ( searchsortutil == NULL )

   188 				{

   189 				CMsvStore* msvStore = iMsvEntry->ReadStoreL();

   190 				CleanupStack::PushL(msvStore);

   191 				iHeader->RestoreL(*msvStore);

   192 				CleanupStack::PopAndDestroy();//store

   193 				CImEmailMessage* message=CImEmailMessage::NewLC(*iMsvEntry);

   194 				message->GetBodyTextL(iMsvEntry->Entry().Id(),CImEmailMessage::EThisMessageOnly,Body(),*iParaFormatLayer,*iCharFormatLayer);

   195 				CleanupStack::PopAndDestroy();//message	

   196 				break;

   197 				}

   198 			}

   199 		};

   200 	}

   201 

   202 EXPORT_C void CImap4ClientMtm::RestoreSettingsL()

   203 /** If the current context of the client MTM is on an IMAP4 service, restores settings 

   204 from the Central Repository. 

   205 

   206 The restored settings can be accessed through the Imap4Settings() function.

   207 

   208 @panic IMCM 33 MTM has no current context (debug builds only)

   209 */

   210     {

   211 	__ASSERT_DEBUG(iMsvEntry!=NULL,gPanic(EImpcNoCMsvEntrySet));

   212 

   213 	CEmailAccounts* account = CEmailAccounts::NewLC();

   214   	TImapAccount id;

   215 	account->GetImapAccountL(iMsvEntry->Entry().Id(), id);

   216 	account->LoadImapSettingsL(id, iImImap4Settings);

   217 	CleanupStack::PopAndDestroy(account);    

   218 	}

   219 

   220 CMsvOperation* CImap4ClientMtm::ReplyL(TMsvId aDestination, TMsvPartList aPartList, TRequestStatus& aCompletionStatus)

   221 /** Creates an SMTP reply message to the current message context.

   222 

   223 @param aDestination Entry to which to assign the reply. 

   224 @param aPartList Defines the parts that are to be copied from the original 

   225 message into the reply.

   226 @param aCompletionStatus The request status to be completed when the operation 

   227 has finished.

   228 @return If successful, this is an asynchronously completing reply operation. 

   229 If failed, this is a completed operation, with status set to the relevant 

   230 error code. */

   231 	{

   232 	TMsvEmailTypeList msvEmailTypeList = 0;

   233 	TUid messageType = KUidMsgTypeSMTP;

   234 	return CImEmailOperation::CreateReplyL(aCompletionStatus, Session(), iMsvEntry->EntryId(), aDestination, aPartList, msvEmailTypeList, messageType);

   235 	}

   236 

   237 CMsvOperation* CImap4ClientMtm::ForwardL(TMsvId aDestination, TMsvPartList aPartList, TRequestStatus& aCompletionStatus)

   238 /** Creates an forwarded SMTP message from the current message context. 

   239 

   240 @param aDestination Entry to which to assign the forwarded message.

   241 @param aPartList Defines the parts that are to be copied from the original 

   242 message into the forwarded message 

   243 @param aCompletionStatus The request status to be completed when the operation 

   244 has finished.

   245 @return If successful, this is an asynchronously completing forward message 

   246 operation. If failed, this is a completed operation, with status set to the 

   247 relevant error code. */

   248 	{

   249 	TMsvEmailTypeList msvEmailTypeList = 0;

   250 	TUid messageType = KUidMsgTypeSMTP;

   251 	return CImEmailOperation::CreateForwardL(aCompletionStatus, Session(), iMsvEntry->EntryId(), aDestination, aPartList, msvEmailTypeList, messageType);

   252    }

   253 

   254 TUint CImap4ClientMtm::ValidateMessage(TUint aPartList)

   255 /** Validates the current message context.

   256 

   257 Only the message recipients and sender fields are checked for well-formed 

   258 addresses.

   259 

   260 @param aPartList Indicates the value of the message parts for which validation 

   261 is requested.

   262 @return Values of message parts. 

   263 

   264 @panic IMCM 33 MTM has no current context (debug builds only)

   265 */

   266 	{

   267 	__ASSERT_DEBUG(iMsvEntry!=NULL,gPanic(EImpcNoCMsvEntrySet));

   268 	TBool retVal=0;

   269 	if (aPartList & KMsvMessagePartRecipient)

   270 		{

   271 		TBool valid = ETrue;

   272 		// check the recipient list for valid 'addresses' - ie no digits

   273 		for (TInt ii=0; ii < AddresseeList().Count(); ++ii)

   274 			if ( (valid = ValidateAddress((*iAddresseeList)[ii])) == EFalse)

   275 				continue;

   276 		retVal += (valid ? 0 : KMsvMessagePartRecipient);

   277 		}

   278 	if (aPartList & KMsvMessagePartOriginator)

   279 		{

   280 		// check the originator field for valid 'addresses' - ie no digits

   281 		if (!ValidateAddress(iMsvEntry->Entry().iDetails))

   282 			retVal += KMsvMessagePartOriginator;

   283 		}

   284 	return retVal;

   285 	}

   286 

   287 TBool CImap4ClientMtm::ValidateAddress(const TPtrC& anAddress)

   288 	{

   289 	return iTImMessageField.ValidInternetEmailAddress(anAddress);

   290 	}

   291 

   292 void CImap4ClientMtm::SendOnNextConnectionL()

   293 	{

   294 	TMsvId smtpServiceId = KMsvNullIndexEntryId;

   295 	TMsvId entry = iMsvEntry->Entry().Id();

   296 	if (iMsvEntry->Entry().iType.iUid==KUidMsvServiceEntryValue)

   297 		smtpServiceId = iMsvEntry->Entry().iRelatedId;

   298 	else if (iMsvEntry->Entry().iType.iUid==KUidMsvMessageEntryValue)

   299 		{

   300 		TMsvId id=iMsvEntry->Entry().iServiceId;

   301 		iMsvEntry->SetEntryL(iMsvEntry->Entry().iServiceId);		

   302 		smtpServiceId = iMsvEntry->Entry().iRelatedId;

   303 		iMsvEntry->SetEntryL(id);		

   304 		}

   305 

   306 	iMsvEntry->SetEntryL(KMsvGlobalOutBoxIndexEntryId);

   307 	CMsvEntrySelection* sel = iMsvEntry->ChildrenWithMtmL(KUidMsgTypeSMTP);

   308 	CleanupStack::PushL(sel);

   309 

   310 	// there is no need to start the autosend operation if there are no SMTP messages

   311 	// in the outbox

   312 

   313 	if(sel->Count())

   314 		{

   315 		TBuf<20> cmdString;

   316 		cmdString.Num(smtpServiceId, EDecimal);

   317 			RProcess p;

   318 			TInt error=p.Create(KMsvAutoSendExe, cmdString, TUidType(KNullUid, KNullUid, KMsvAutoSendExeUid));

   319 			if (error==KErrNone)

   320 				{

   321 				p.Resume();

   322 				p.Close();

   323 				}

   324 		}

   325 	CleanupStack::PopAndDestroy(sel);

   326 	iMsvEntry->SetEntryL(entry);

   327 	}

   328 

   329 TMsvPartList CImap4ClientMtm::DoFindL(const TDesC& aTextToFind, TMsvPartList aPartList)

   330 	{ 

   331 	CImClientMTMUtils* clientMTMUtils = CImClientMTMUtils::NewL();

   332 	CleanupStack::PushL(clientMTMUtils);

   333 

   334 	TMsvPartList retList = KMsvMessagePartNone;

   335 	CMsvFindText* findText = CMsvFindText::NewLC();

   336  

   337   	

   338 	// Get a reference to TMsvEnhanceSearchSortUtil  instance set by CMsvSearchsortOpOnHeaderBody class

   339 		

   340 	TMsvEnhanceSearchSortUtil* searchsortutil = (TMsvEnhanceSearchSortUtil*)(GetExtensionData());

   341 	

   342 	if( searchsortutil != NULL )

   343  		{

   344  		// Get Advanced search sort setting flag

   345  		TInt32 searchsortsetting=searchsortutil->GetSearchSortSetting();

   346  		

   347  		/* If the search is on message body than Load message Body 

   348  		 If the search is on message header than Load the message header

   349  		 Also set searchsortsetting flag EMessagePartBodyLoaded or EMessagePartHeaderLoaded 

   350  		 in TMsvEnhanceSearchSortUtil class

   351  		 This ensures that the body or header is not loaded twice if 2 query options

   352  		 are on the body */

   353  		

   354  		if(aPartList & KMsvMessagePartBody && !(searchsortsetting & EMessagePartBodyLoaded))  	

   355    			{

   356    			CImEmailMessage* message=CImEmailMessage::NewLC(*iMsvEntry);

   357 			message->GetBodyTextL(iMsvEntry->Entry().Id(),CImEmailMessage::EThisMessageOnly,Body(),*iParaFormatLayer,*iCharFormatLayer);

   358 			CleanupStack::PopAndDestroy();//message

   359 			searchsortutil->SetSearchSortSetting(EMessagePartBodyLoaded);

   360    			}

   361    		else if(!(searchsortsetting & EMessagePartHeaderLoaded))

   362    			{

   363    			// Load the header

   364 			CMsvStore* msvStore = iMsvEntry->ReadStoreL();

   365 			CleanupStack::PushL(msvStore);

   366 			iHeader->RestoreL(*msvStore);

   367 			CleanupStack::PopAndDestroy();//store

   368 			searchsortutil->SetSearchSortSetting(EMessagePartHeaderLoaded);	

   369    			}

   370    			

   371    		// Issue the Find request

   372 		clientMTMUtils->FindL(aTextToFind, Body(), *iHeader, aPartList, retList);

   373 		

   374 		/* If the search didn't succeed, than search in the details field of TMsvEntry class. It holds the From field

   375 		   If the search is on subject, than look in description field of TMsvEntry class.	*/

   376 		   

   377 		if(!retList)

   378 			{

   379 			if (aPartList & KMsvMessagePartFrom)

   380 				{

   381 				findText->FindTextL(aTextToFind, iMsvEntry->Entry().iDetails, aPartList) ? retList|=KMsvMessagePartOriginator : retList;	

   382 				}

   383  			if (aPartList & KMsvMessagePartSubject)

   384  				{

   385  				findText->FindTextL(aTextToFind, iMsvEntry->Entry().iDescription, aPartList) ? retList|=KMsvMessagePartDescription : retList;	

   386  				}

   387 			}

   388 		

   389 		/* Copy the sort data if sorting is specified.

   390 		 The operations being performed could be only be sort or it could be search and sort

   391 		 If the operation is search and sort than copy the sort data only if the

   392 		 search operation succeeded	*/

   393 		if ((searchsortsetting & EMessagePartSort ) || ((searchsortsetting & EMessagePartSearchSort) && (searchsortsetting & EMessagePartLastQueryOption) && (retList)))

   394    			{

   395    			/* Copy the data to be sorted from the header stream.

   396    			   This done by setting iExtensionData to point to the field being copied */

   397    			if (iHeader)

   398    				{

   399    				if (searchsortsetting & EMessagePartToSort )

   400    					{

   401 	   				SetExtensionData((TAny*)&iHeader->ToRecipients());

   402    					}

   403    				else if(searchsortsetting & EMessagePartCcSort)

   404    					{

   405    					SetExtensionData((TAny*)&iHeader->CcRecipients());

   406 	   				}

   407    				else if(searchsortsetting & EMessagePartBccSort)

   408     				{

   409     				SetExtensionData((TAny*)&iHeader->BccRecipients());

   410 	    			}

   411     			else if(searchsortsetting & EMessagePartFromSort)

   412     				{

   413     				SetExtensionData((TAny*)(iHeader->From().Ptr()));

   414     				}

   415 				else if(searchsortsetting & EMessagePartSubjectSort)

   416 					{

   417 					SetExtensionData((TAny*)(iHeader->Subject().Ptr()));

   418 					}

   419     			}

   420    			else // Header not present. Copy sort data from TMsvEntry details and description field

   421    	   			{

   422 	   		    if(searchsortsetting & EMessagePartFromSort)

   423 	   		    	{

   424 	   		    	SetExtensionData((TAny*)&iMsvEntry->Entry().iDetails);	

   425 	   		    	}

   426 	  			else if(searchsortsetting & EMessagePartSubjectSort)

   427    					{

   428    					SetExtensionData((TAny*)&iMsvEntry->Entry().iDescription);		

   429    					}

   430    	   			}

   431    			}

   432  		}

   433 	else

   434 		{

   435 

   436 		// Old implementation for searching

   437 		clientMTMUtils->FindL(aTextToFind, Body(), *iHeader, aPartList, retList);

   438 		

   439 		if(!retList)

   440 			{

   441 			if (aPartList & KMsvMessagePartOriginator)

   442 				{

   443 				findText->FindTextL(aTextToFind, iMsvEntry->Entry().iDetails, aPartList) ? retList|=KMsvMessagePartOriginator : retList;	

   444 				}

   445  			if (aPartList & KMsvMessagePartDescription)

   446  				{

   447  				findText->FindTextL(aTextToFind, iMsvEntry->Entry().iDescription, aPartList) ? retList|=KMsvMessagePartDescription : retList;	

   448  				}

   449 			}

   450 		}

   451 	CleanupStack::PopAndDestroy(findText);

   452 	CleanupStack::PopAndDestroy(clientMTMUtils); 

   453 	return retList;

   454 	}

   455 

   456 TMsvPartList CImap4ClientMtm::Find(const TDesC& aTextToFind, TMsvPartList aPartList)

   457 /** Searches the specified message part(s) for the plain-text version of the text 

   458 to be found. 

   459 

   460 @param aTextToFind The plain-text version of the text to be found. 

   461 @param aPartList Indicates the message parts which should be searched.

   462 @return If the text was not found, or searching is unsupported, 0. If the text 

   463 was found, a bitmask of the TMsvPartList IDs for each part in which the text 

   464 was present. */

   465 	{

   466  	TMsvPartList retList = KMsvMessagePartNone;

   467  	TRAPD(ret, retList = DoFindL(aTextToFind, aPartList));

   468    	return retList;

   469 	}

   470 

   471 TInt CImap4ClientMtm::QueryCapability(TUid aCapability, TInt& aResponse)

   472 /** Queries if the MTM supports a particular capability, specified by a UID.

   473 

   474 @param aCapability UID of capability to be queried. See MTMDEF.HRH for 

   475 definition of UIDs. 

   476 @param aResponse Response value. The format of the response varies according 

   477 to the capability. 

   478 @return KErrNone: aCapability is a recognised value and a response is returned 

   479 KErrNotSupported: aCapability is not a recognised value 

   480 */

   481 	{

   482 	TInt error = KErrNone;

   483    const TInt KImap4MaxTextMessageSize = 0xFFFF;

   484 	switch (aCapability.iUid)

   485 		{

   486 	case KUidMtmQueryMaxBodySizeValue:

   487 	case KUidMtmQueryMaxTotalMsgSizeValue:

   488 		aResponse = KImap4MaxTextMessageSize;

   489 		break;

   490 	case KUidMtmQuerySupportedBodyValue:

   491 		aResponse = KMtm7BitBody + KMtm8BitBody + KMtm16BitBody + KMtmBinaryBody;

   492 		break;

   493    // Supported

   494 	case KUidMtmQueryCanReceiveMsgValue:		

   495    case KUidMtmQuerySupportAttachmentsValue:

   496    case KUidMtmQuerySupportsFolderValue:

   497 		break;

   498 	// Not supported

   499 	case KUidMtmQueryOffLineAllowedValue:	

   500 	case KUidMtmQueryCanSendMsgValue:		

   501 	default:

   502 		aResponse = ETrue;

   503 		return KErrNotSupported;

   504 		}

   505 	return error;

   506 	}

   507 

   508 void CImap4ClientMtm::InvokeSyncFunctionL(TInt aFunctionId, const CMsvEntrySelection& aSelection, TDes8& aParameter)

   509 /** Invokes synchronous IMAP-specific operations.

   510 

   511 @param aFunctionId ID of the requested function. Supported IDs are #KIMAP4MTMIsConnected and #KIMAP4MTMBusy.

   512 @param aSelection Collection of function entries to invoke.

   513 @param aParameter Buffer containing input and output parameters. 

   514 

   515 @panic IMCM 33 MTM has no current context (debug builds only)

   516 @leave KErrNotSupported Function does not provide function specified by aFunctionId

   517 @see #KIMAP4MTMIsConnected 

   518 @see #KIMAP4MTMBusy

   519 */

   520 	{

   521 	__ASSERT_DEBUG(iMsvEntry!=NULL,gPanic(EImpcNoCMsvEntrySet));

   522 	TInt error = KErrNone;

   523 	switch (aFunctionId)

   524 		{

   525 	case KIMAP4MTMIsConnected:

   526    case KIMAP4MTMBusy:

   527 		{

   528 		CMsvOperationActiveSchedulerWait *wait = CMsvOperationActiveSchedulerWait::NewLC();

   529 		CMsvOperation* operation = Session().TransferCommandL(aSelection, aFunctionId, aParameter, wait->iStatus);

   530 		CleanupStack::PushL(operation);

   531 		wait->iStatus = KRequestPending;

   532 		wait->Start();

   533       error = operation->iStatus.Int();

   534 		CleanupStack::PopAndDestroy(2); //operation, wait

   535 		// return the result via aParameter as a TInt packaged into a TDes8

   536 		TPckgBuf<TInt> resultPackage(error);

   537 		aParameter.Copy(resultPackage);

   538       return;

   539 		}

   540 	default:

   541 		error=KErrNotSupported;

   542 		break;

   543 		}

   544 	User::LeaveIfError(error);

   545 	}

   546 

   547 CMsvOperation* CImap4ClientMtm::InvokeAsyncFunctionL(TInt aFunctionId,

   548 												const CMsvEntrySelection& aSelection, 

   549 												TDes8& aParameter, 

   550 												TRequestStatus& aCompletionStatus)

   551 /** Invokes asynchronous IMAP-specific operations.

   552 

   553 This provides support for a large number of IMAP-specific functions, including

   554 operations to:

   555 

   556 - Connect and logon to a remote server

   557 - Synchronise headers

   558 - Subscribe to mailboxes

   559 - Populate messages

   560 - Copy messages

   561 - Move messages

   562 - Create messages

   563 - Set offline behaviour

   564 

   565 For details of operations, see #TImap4Cmds.

   566 

   567 @param aFunctionId Specifies which operation to perform e.g. connect, copy 

   568 new mail etc. The specific operations are defined by the #TImap4Cmds enumeration. 

   569 @param aSelection A selection of messages. The use is dependant upon the command 

   570 specified by @c aFunctionID.

   571 @param aParameter Use is dependant upon the command specified by @c aFunctionID

   572 @param aCompletionStatus The status when the operation completes. 

   573 @leave KErrNotFound The selection of email to be moved or copied is empty

   574 @leave KErrNotSupported The specified operation is not recognised

   575 @return If successful, this is an asynchronously completing operation. If failed, 

   576 this is a completed operation, with status set to the relevant error code. 

   577 @panic IMCM 33 MTM has no current context (debug builds only)

   578 @see TImap4Cmds */

   579 	{

   580     __ASSERT_DEBUG(iMsvEntry!=NULL,gPanic(EImpcNoCMsvEntrySet));

   581 	CMsvOperation* operation = NULL;

   582 	switch (aFunctionId)

   583 		{

   584 	case KIMAP4MTMConnect:

   585 	case KIMAP4MTMConnectAndSynchronise:

   586 	case KIMAP4MTMDisconnect:

   587 		if (aFunctionId!=KIMAP4MTMDisconnect)

   588 			{

   589 			RestoreSettingsL();

   590 			if (iImImap4Settings.AutoSendOnConnect()) //hope iImPop3Settings is restored by this stage

   591 				{

   592 				TRAPD(err,SendOnNextConnectionL());  //ignore the error and continue with connecting

   593 				}

   594 			}

   595 		operation = (Session().TransferCommandL(aSelection, aFunctionId, aParameter, aCompletionStatus));

   596 		break;

   597 	case KIMAP4MTMCancelBackgroundSynchronise:

   598 	case KIMAP4MTMStartBatch:

   599 	case KIMAP4MTMEndBatch:

   600 	case KIMAP4MTMBusy:

   601 	case KIMAP4MTMSelect:

   602 	case KIMAP4MTMSynchronise:

   603 	case KIMAP4MTMSyncTree:

   604 	case KIMAP4MTMSyncSubscription:

   605 	case KIMAP4MTMFullSync:

   606 	case KIMAP4MTMLocalSubscribe:

   607 	case KIMAP4MTMLocalUnsubscribe:

   608 	case KIMAP4MTMInboxNewSync:

   609 	case KIMAP4MTMFolderFullSync:

   610 	case KIMAP4MTMWaitForBackground:

   611 	case KIMAP4MTMRenameFolder:

   612 	case KIMAP4MTMUndeleteAll:

   613 	case KIMAP4MTMCancelOffLineOperations:

   614 	case KIMAP4MTMPopulate:

   615 		{

   616 		if(aFunctionId == KIMAP4MTMPopulate)

   617 			{

   618 			ConvertToPartialPopulate(aParameter);

   619 			return (Session().TransferCommandL(aSelection, aFunctionId, iImap4GetPartialMailInfo, aCompletionStatus));

   620 			}

   621 		operation = (Session().TransferCommandL(aSelection, aFunctionId, aParameter, aCompletionStatus));

   622 		}

   623 		break;

   624 	case KIMAP4MTMConnectAndSyncCompleteAfterConnect:

   625 	case KIMAP4MTMConnectAndSyncCompleteAfterFullSync:

   626 	case KIMAP4MTMConnectAndSyncCompleteAfterDisconnect:

   627 		{

   628 		TImapConnectionCompletionState connectAndSyncCompleteState = EAfterConnect;

   629 		switch (aFunctionId)

   630 			{

   631 			case KIMAP4MTMConnectAndSyncCompleteAfterConnect:

   632 				connectAndSyncCompleteState = EAfterConnect;

   633 				break;

   634 			case KIMAP4MTMConnectAndSyncCompleteAfterFullSync:

   635 				connectAndSyncCompleteState = EAfterFullSync;

   636 				break;

   637 			case KIMAP4MTMConnectAndSyncCompleteAfterDisconnect:

   638 				connectAndSyncCompleteState = EAfterDisconnection;

   639 				break;

   640 			default:

   641 				break;

   642 			}

   643 

   644 		MMsvImapConnectionObserver* connectionObserver;

   645 		TPckgC<MMsvImapConnectionObserver*> paramPack(connectionObserver);

   646 		paramPack.Set(aParameter);

   647 		connectionObserver = paramPack();

   648 

   649 		operation = CImapConnectAndSyncOp::NewL(Session(),

   650 												aSelection,

   651 												*this,

   652 												CActive::EPriorityStandard,

   653 												aCompletionStatus,

   654 												connectAndSyncCompleteState,

   655 												connectionObserver);

   656 		}

   657 		break;

   658 	case KIMAP4MTMCopyNewMailWhenAlreadyConnected:

   659 	case KIMAP4MTMCopyAllMailWhenAlreadyConnected:

   660 	case KIMAP4MTMCopyMailSelectionWhenAlreadyConnected:

   661 	case KIMAP4MTMMoveNewMailWhenAlreadyConnected:

   662 	case KIMAP4MTMMoveMailSelectionWhenAlreadyConnected:

   663 	case KIMAP4MTMMoveAllMailWhenAlreadyConnected:

   664 	case KIMAP4MTMPopulateNewMailWhenAlreadyConnected:

   665 	case KIMAP4MTMPopulateAllMailWhenAlreadyConnected:

   666 	case KIMAP4MTMPopulateMailSelectionWhenAlreadyConnected:

   667 		{

   668 		delete iMsvEntrySelection;

   669 		iMsvEntrySelection = new(ELeave) CMsvEntrySelection();

   670 		ConvertToPartialPopulate(aParameter);

   671 		switch (aFunctionId)

   672 			{

   673 			case KIMAP4MTMCopyNewMailWhenAlreadyConnected:

   674 			case KIMAP4MTMCopyAllMailWhenAlreadyConnected:

   675 			case KIMAP4MTMMoveNewMailWhenAlreadyConnected:

   676 			case KIMAP4MTMMoveAllMailWhenAlreadyConnected:

   677 			case KIMAP4MTMPopulateNewMailWhenAlreadyConnected:

   678 			case KIMAP4MTMPopulateAllMailWhenAlreadyConnected:

   679 				{

   680 				FilterAllOrNewMailsL(aFunctionId,aSelection,iImap4GetPartialMailInfo);

   681 				}

   682 				break;

   683 			case KIMAP4MTMCopyMailSelectionWhenAlreadyConnected:

   684 			case KIMAP4MTMMoveMailSelectionWhenAlreadyConnected:

   685 			case KIMAP4MTMPopulateMailSelectionWhenAlreadyConnected:

   686 				{

   687 				FilterMailSelectionL(aSelection,iImap4GetPartialMailInfo);

   688 				}

   689 				break;

   690 			}

   691 

   692 		// only need to do copy/move if the selection is not empty

   693 		if (iMsvEntrySelection->Count()>0)

   694 			{

   695 			return CopyMoveOrPopulateL(aFunctionId,iImap4GetPartialMailInfo,aCompletionStatus);

   696 			}

   697 		else

   698 			operation = CMsvCompletedOperation::NewL(Session(), KUidMsgTypeIMAP4, KNullDesC8, iMsvEntry->Entry().iServiceId, aCompletionStatus);	

   699 		}

   700 		break;

   701 	case KIMAP4MTMConnectAndCopyNewMailAndStayOnline:

   702 	case KIMAP4MTMConnectAndCopyNewMailAndDisconnect:

   703 	case KIMAP4MTMConnectAndCopyAllMailAndStayOnline:

   704 	case KIMAP4MTMConnectAndCopyAllMailAndDisconnect:

   705 	case KIMAP4MTMConnectAndCopyMailSelectionAndStayOnline:

   706 	case KIMAP4MTMConnectAndCopyMailSelectionAndDisconnect:

   707 	case KIMAP4MTMConnectAndMoveNewMailAndStayOnline:

   708 	case KIMAP4MTMConnectAndMoveNewMailAndDisconnect:

   709 	case KIMAP4MTMConnectAndMoveAllMailAndStayOnline:

   710 	case KIMAP4MTMConnectAndMoveAllMailAndDisconnect:

   711 	case KIMAP4MTMConnectAndMoveMailSelectionAndStayOnline:

   712 	case KIMAP4MTMConnectAndMoveMailSelectionAndDisconnect:

   713 	case KIMAP4MTMConnectAndPopulateNewMailAndStayOnline:

   714 	case KIMAP4MTMConnectAndPopulateNewMailAndDisconnect:

   715 	case KIMAP4MTMConnectAndPopulateAllMailAndStayOnline:

   716 	case KIMAP4MTMConnectAndPopulateAllMailAndDisconnect:

   717 	case KIMAP4MTMConnectAndPopulateMailSelectionAndStayOnline:

   718 	case KIMAP4MTMConnectAndPopulateMailSelectionAndDisconnect:

   719 		{

   720 		ConvertToPartialPopulate(aParameter);

   721 		return iImIMAP4GetMail->GetMailL(aFunctionId, *this, aSelection, iImap4GetPartialMailInfo, aCompletionStatus);

   722 		}

   723 	case KIMAP4MTMCreateNewEmailMessage:

   724 	case KIMAP4MTMCreateReplyEmailMessage:

   725 	case KIMAP4MTMCreateForwardEmailMessage:

   726 	case KIMAP4MTMCreateForwardAsAttachmentEmailMessage:

   727 	case KIMAP4MTMCreateReceiptEmailMessage:

   728 		{

   729 		TImCreateMessageOptions createMessageOptions;	

   730 		TPckgC<TImCreateMessageOptions> paramPack(createMessageOptions);

   731 		paramPack.Set(aParameter);

   732 		switch (aFunctionId)

   733 			{

   734 		case KIMAP4MTMCreateNewEmailMessage:

   735 			return iImEmailOperation->CreateNewL(aCompletionStatus, iMsvEntry->Session(), aSelection[0], paramPack().iMsvPartList, paramPack().iMsvEmailTypeList, paramPack().iMessageType);

   736 		case KIMAP4MTMCreateReplyEmailMessage:

   737 			return iImEmailOperation->CreateReplyL(aCompletionStatus, iMsvEntry->Session(), aSelection[1], aSelection[0], paramPack().iMsvPartList, paramPack().iMsvEmailTypeList, paramPack().iMessageType);

   738 		case KIMAP4MTMCreateForwardEmailMessage:

   739 			return iImEmailOperation->CreateForwardL(aCompletionStatus, iMsvEntry->Session(), aSelection[1], aSelection[0], paramPack().iMsvPartList, paramPack().iMsvEmailTypeList, paramPack().iMessageType);

   740 		case KIMAP4MTMCreateForwardAsAttachmentEmailMessage:

   741 			return iImEmailOperation->CreateForwardAsAttachmentL(aCompletionStatus, iMsvEntry->Session(), aSelection[1], aSelection[0], paramPack().iMsvPartList, paramPack().iMsvEmailTypeList, paramPack().iMessageType);

   742 		case KIMAP4MTMCreateReceiptEmailMessage:

   743 			return iImEmailOperation->CreateReceiptL(aCompletionStatus, iMsvEntry->Session(), aSelection[1], aSelection[0], paramPack().iMsvPartList, paramPack().iMsvEmailTypeList, paramPack().iMessageType);

   744 		default:

   745 			User::Leave(KErrNotSupported);

   746 			return NULL;	// shouldn't really get here!

   747 			}

   748 		}

   749 	default:

   750 		User::Leave(KErrNotSupported);

   751 		return NULL;

   752 		}

   753 	return operation;

   754 }

   755 

   756 /** Converts the full download information to partial download informations with parameters 

   757 for partial download information set to  defaults. This package will later be interpreted by 

   758 server to check whether it is for full download or partial download.

   759 

   760 @param aParameter Contains information about full fetch of a message or

   761 partial fetch of a message .

   762 */

   763 void CImap4ClientMtm::ConvertToPartialPopulate(TDes8& aParameter)

   764 	{

   765 	if(aParameter.Length() == sizeof(TImImap4GetPartialMailInfo))

   766 		{

   767 		iImap4GetPartialMailInfo.Copy(aParameter);

   768 		}

   769 	else

   770 		{

   771 		TImImap4GetMailInfo imap4GetMailInfo;	

   772 		TPckgC<TImImap4GetMailInfo> paramPack(imap4GetMailInfo);

   773 		paramPack.Set(aParameter);

   774 		// Copy TImImap4GetMailInfo information into TImImap4GetPartialMailInfo

   775 		TImImap4GetPartialMailInfo imap4GetPartialMailInfo;

   776 		imap4GetPartialMailInfo.iGetMailBodyParts = paramPack().iGetMailBodyParts;

   777 		imap4GetPartialMailInfo.iMaxEmailSize = paramPack().iMaxEmailSize;

   778 		imap4GetPartialMailInfo.iDestinationFolder = paramPack().iDestinationFolder;

   779 

   780 		// Set the remaining members to default so that the server can check 

   781 		// if these are defaults, then this package is for TImImap4GetMailInfo

   782 		imap4GetPartialMailInfo.iTotalSizeLimit	= KMaxTInt;

   783 		imap4GetPartialMailInfo.iBodyTextSizeLimit = KMaxTInt;

   784 		imap4GetPartialMailInfo.iAttachmentSizeLimit = KMaxTInt;

   785 		imap4GetPartialMailInfo.iPartialMailOptions = ENoSizeLimits;

   786 		

   787 		iImap4GetPartialMailInfo = imap4GetPartialMailInfo;

   788 		}

   789 	}

   790 

   791 /** Returns whether aParameter contains information for partial fetch of full fetch

   792 

   793 @param aParameter Contains information about full fetch of a message or

   794 partial fetch of a message .

   795 

   796 @return ETrue if aParamter contains information for partial fetch

   797 else EFalse indicates it has information for full download of a message

   798 */

   799 TBool CImap4ClientMtm::IsPartialPopulate(TDes8& aParameter)

   800 	{

   801 	TBool isPartialPopulate = EFalse;

   802 	if(aParameter.Length() == sizeof(TImImap4GetPartialMailInfo))

   803 		{

   804 		TImImap4GetPartialMailInfo iImapGetPartialMailInfo;

   805 		TPckgC<TImImap4GetPartialMailInfo>	pkgPartial(iImapGetPartialMailInfo);

   806 		pkgPartial.Set(aParameter);

   807 

   808 		if(pkgPartial().iPartialMailOptions == ENoSizeLimits &&

   809 			pkgPartial().iTotalSizeLimit == KMaxTInt &&

   810 			pkgPartial().iBodyTextSizeLimit == KMaxTInt && 

   811 			pkgPartial().iAttachmentSizeLimit == KMaxTInt && 

   812 			(pkgPartial().iGetMailBodyParts == EGetImap4EmailHeaders || 

   813 			pkgPartial().iGetMailBodyParts == EGetImap4EmailBodyText ||

   814 			pkgPartial().iGetMailBodyParts == EGetImap4EmailBodyTextAndAttachments ||

   815 			pkgPartial().iGetMailBodyParts == EGetImap4EmailAttachments ||

   816 			pkgPartial().iGetMailBodyParts == EGetImap4EmailBodyAlternativeText))

   817 			{

   818 			isPartialPopulate = EFalse;

   819 			}

   820 		else

   821 			{

   822 			isPartialPopulate = ETrue;

   823 			}

   824 		}

   825 	else

   826 		{

   827 		isPartialPopulate = EFalse;

   828 		}

   829 	return isPartialPopulate;

   830 	}

   831 

   832 /** Copies or moves the selection only if the selection is not empty

   833 

   834 @param aFunctionId Specifies which operation to perform e.g. copy new mail, Move or Populate.

   835 The specific operations are defined by the TImap4Cmds enumeration. 

   836 @param aParameter Use is dependant upon the command specified by aFunctionID

   837 @param aCompletionStatus The status when the operation completes. 

   838 @return If successful, this is an asynchronously completing operation. If failed, 

   839 this is a completed operation, with status set to the relevant error code. 

   840 */

   841 CMsvOperation* CImap4ClientMtm::CopyMoveOrPopulateL(TInt aFunctionId,TDes8& aParameter,TRequestStatus& aCompletionStatus)

   842 	{

   843 	// set entry to the parent of the selection of messages

   844 	// assumes the selection of messages have the same parent i.e. in the same folder

   845 	CMsvOperation* operation = NULL;

   846 	TMsvEmailEntry entry;

   847 	TMsvId service = KMsvNullIndexEntryId;

   848 	iMsvEntry->Session().GetEntry((*iMsvEntrySelection)[0], service, entry);

   849 	iMsvEntry->SetEntryL(entry.Parent());

   850 	

   851 	// Unpackage TImImap4GetPartialMailInfo

   852 	TImImap4GetPartialMailInfo imap4GetMailInfo;	

   853 	TPckgC<TImImap4GetPartialMailInfo> paramPack(imap4GetMailInfo);

   854 	paramPack.Set(aParameter);	

   855 

   856 	if ((aFunctionId == KIMAP4MTMCopyNewMailWhenAlreadyConnected) ||

   857 		(aFunctionId == KIMAP4MTMCopyMailSelectionWhenAlreadyConnected) ||

   858 		(aFunctionId == KIMAP4MTMCopyAllMailWhenAlreadyConnected))

   859 		{

   860 		return iMsvEntry->CopyL(*iMsvEntrySelection, paramPack().iDestinationFolder, aCompletionStatus);

   861 		}

   862 	else if ((aFunctionId == KIMAP4MTMMoveNewMailWhenAlreadyConnected) ||

   863 		(aFunctionId == KIMAP4MTMMoveMailSelectionWhenAlreadyConnected) ||

   864 		(aFunctionId == KIMAP4MTMMoveAllMailWhenAlreadyConnected))

   865 		{

   866 		return iMsvEntry->MoveL(*iMsvEntrySelection, paramPack().iDestinationFolder, aCompletionStatus);

   867 		}

   868 	else //KIMAP4MTMPopulateMailSelectionWhenAlreadyConnected,KIMAP4MTMPopulateNewMailWhenAlreadyConnected,KIMAP4MTMPopulateAllMailWhenAlreadyConnected

   869 		{

   870 		operation = Session().TransferCommandL(*iMsvEntrySelection, KIMAP4MTMPopulate, paramPack, aCompletionStatus);		

   871 		return operation;

   872 		}

   873 	}

   874 

   875 /** Filter the selection of messages for all mails or new mails

   876 

   877 @param aFunctionId Specifies which operation to perform e.g. connect, copy 

   878 new mail etc. The specific operations are defined by the TImap4Cmds enumeration. 

   879 @param aSelection A selection of messages. The use is dependant upon the command 

   880 specified by aFunctionID.

   881 @param aParameter Use is dependant upon the command specified by aFunctionID . 

   882 This can have information for full fetch or partial fetch of a message. 

   883 */

   884 void CImap4ClientMtm::FilterAllOrNewMailsL(TInt aFunctionId,	const CMsvEntrySelection& aSelection,TDes8& aParameter)

   885 	{

   886 	iMsvEntry->SetEntryL(aSelection[1]); // set entry to the folder from which to copy/move

   887 	// get a selection of messages

   888 	CMsvEntrySelection* msvEntrySelection = iMsvEntry->ChildrenWithTypeL(KUidMsvMessageEntry);

   889 	CleanupStack::PushL(msvEntrySelection);

   890 	TMsvId messageId;

   891 	// get a selection of messages which are new - i.e have new flag set.

   892 	//	from the selection of messages under the service

   893 	for (TInt i=0; i<msvEntrySelection->Count(); i++)

   894 		{

   895 		messageId = (*msvEntrySelection)[i];

   896 		TMsvEmailEntry entry;

   897 		TMsvId service = KMsvNullIndexEntryId;

   898 		iMsvEntry->Session().GetEntry(messageId, service, entry);

   899 

   900 		TImImap4GetPartialMailInfo imap4GetPartialMailInfo;	

   901 		TPckgC<TImImap4GetPartialMailInfo> paramPack(imap4GetPartialMailInfo);

   902 		paramPack.Set(aParameter);

   903 			

   904         TBool isComplete = ! ((entry.Complete() && entry.PartialDownloaded()) ||

   905 							 	(!entry.Complete() && 

   906 							 		(!entry.BodyTextComplete() 

   907 							 		|| (paramPack().iGetMailBodyParts ==  EGetImap4EmailBodyTextAndAttachments)) 

   908 							 		   && !entry.PartialDownloaded()));

   909 		if ((aFunctionId == KIMAP4MTMCopyNewMailWhenAlreadyConnected) ||

   910 			(aFunctionId == KIMAP4MTMMoveNewMailWhenAlreadyConnected) ||

   911 			(aFunctionId == KIMAP4MTMPopulateNewMailWhenAlreadyConnected))

   912 			{

   913 

   914 			if(aFunctionId == KIMAP4MTMPopulateNewMailWhenAlreadyConnected && IsPartialPopulate(aParameter) && !isComplete)

   915 				{

   916 				if ((entry.iType == KUidMsvMessageEntry) && (entry.New()))

   917 					iMsvEntrySelection->AppendL(messageId);

   918 				}

   919 			else

   920 				{

   921 				if ((entry.iType == KUidMsvMessageEntry) && (entry.New()) && (entry.iSize <= paramPack().iMaxEmailSize))

   922 					{

   923 					if ((isComplete && aFunctionId == KIMAP4MTMPopulateNewMailWhenAlreadyConnected) ||

   924 					 	(entry.Parent() == paramPack().iDestinationFolder && (aFunctionId == KIMAP4MTMMoveNewMailWhenAlreadyConnected || isComplete)))

   925 						{

   926 						// Selected entries are filtered from the original list if this is a 

   927 						// populate operation and the message is complete.

   928 						//

   929 						// Note that a copy to local operation where the destination folder is

   930 						// the same as the source folder is equivalent to a populate operation

   931 						// as the contents of the message are fetched to the local mirror folder

   932 						// and hence complete messages are removed from the list in this case.

   933 						//

   934 						// Move operations where the source and destination folder are the same

   935 						// are not supported and are also filtered from the original list.

   936 						}

   937 					else

   938 						{

   939 						iMsvEntrySelection->AppendL(messageId);

   940 						}

   941 					}

   942 				}

   943 			}

   944 		else // KIMAP4MTMCopyAllMailWhenAlreadyConnected, KIMAP4MTMMoveAllMailWhenAlreadyConnected, KIMAP4MTMPopulateAllMailWhenAlreadyConnected

   945 			{

   946 			

   947 			if(aFunctionId == KIMAP4MTMPopulateAllMailWhenAlreadyConnected && IsPartialPopulate(aParameter) && !isComplete)

   948 				{

   949 				if ((entry.iType == KUidMsvMessageEntry) && !entry.Complete())

   950 					iMsvEntrySelection->AppendL(messageId);

   951 				}

   952 			else

   953 				{

   954 				if ((entry.iType == KUidMsvMessageEntry) && (entry.iSize <= paramPack().iMaxEmailSize))

   955 					{

   956 					if ((isComplete && aFunctionId == KIMAP4MTMPopulateAllMailWhenAlreadyConnected) ||

   957 					 (entry.Parent() == paramPack().iDestinationFolder && (aFunctionId == KIMAP4MTMMoveAllMailWhenAlreadyConnected || isComplete)))

   958 						{

   959 						// Selected entries are filtered from the original list if this is a 

   960 						// populate operation and the message is complete.

   961 						//

   962 						// Note that a copy to local operation where the destination folder is

   963 						// the same as the source folder is equivalent to a populate operation

   964 						// as the contents of the message are fetched to the local mirror folder

   965 						// and hence complete messages are removed from the list in this case.

   966 						//

   967 						// Move operations where the source and destination folder are the same

   968 						// are not supported and are also filtered from the original list.

   969 						}

   970 					else

   971 						{

   972 						iMsvEntrySelection->AppendL(messageId);

   973 						}

   974 					}

   975 				}

   976 			}

   977 		}

   978 	CleanupStack::PopAndDestroy(); //msvEntrySelection;

   979 	}	

   980 

   981 /** Filters the mails selected for partial fetch or full fetch of messages

   982 

   983 @param aSelection A selection of messages. The use is dependant upon the command 

   984 specified by aFunctionID.

   985 @param aParameter Use is dependant upon the command specified by aFunctionID . 

   986 This can have information for full fetch or partial fetch of a message. 

   987 */

   988 void CImap4ClientMtm::FilterMailSelectionL(const CMsvEntrySelection& aSelection,TDes8& aParameter)

   989 	{

   990 	iMsvEntry->SetEntryL(aSelection[0]); // set entry to service

   991 	TMsvId messageId;

   992 	// get the selection of messages from aSelection (note first element of the

   993 	// CMsvEntrySelection is the service which is then followed by any messages

   994 	for (TInt i=0; i<aSelection.Count(); i++)

   995 		{

   996 		messageId = (aSelection)[i];

   997 		if (i>0) // since 1st element is the service

   998 			{

   999 			TMsvEmailEntry entry;

  1000 			TMsvId service = KMsvNullIndexEntryId;			

  1001 			User::LeaveIfError(iMsvEntry->Session().GetEntry(messageId, service, entry));

  1002 			TImImap4GetPartialMailInfo imap4GetPartialMailInfo;	

  1003 			TPckgC<TImImap4GetPartialMailInfo> paramPack(imap4GetPartialMailInfo);

  1004 			paramPack.Set(aParameter);

  1005 			

  1006 			  TBool isComplete = ! ((entry.Complete() && entry.PartialDownloaded()) ||

  1007 								 	(!entry.Complete() && 

  1008 								 		(!entry.BodyTextComplete() 

  1009 					 					|| (paramPack().iGetMailBodyParts ==  EGetImap4EmailBodyTextAndAttachments)) 

  1010 					 		   			   && !entry.PartialDownloaded()));

  1011 

  1012 			if(IsPartialPopulate(aParameter) && !isComplete)

  1013 				{

  1014 				if ((entry.iType == KUidMsvMessageEntry))

  1015 					iMsvEntrySelection->AppendL(messageId);	

  1016 				}

  1017 			else

  1018 				{

  1019 

  1020 				if ((entry.iType == KUidMsvMessageEntry) && (entry.iSize <= paramPack().iMaxEmailSize))

  1021 					{

  1022 					if(entry.Parent() == paramPack().iDestinationFolder && isComplete)

  1023 						{

  1024 						// do not append if this is a populate operation and the message is complete

  1025 						}

  1026 					else

  1027 						{

  1028 						iMsvEntrySelection->AppendL(messageId);			

  1029 						}

  1030 					}

  1031 				}

  1032 			}

  1033 		}

  1034 	}

  1035 

  1036 void CImap4ClientMtm::HandleEntryEvent(TMsvEntryEvent /*aEvent*/, TAny* /*aArg1*/, TAny* /*aArg2*/, TAny* /*aArg3*/)

  1037 	{    

  1038 	}

  1039 

  1040 //

  1041 // CImImap4Settings wrapper functions

  1042 EXPORT_C void CImap4ClientMtm::SetImap4SettingsL(const CImImap4Settings& aSettings)

  1043 /** Sets the IMAP4 email service settings.

  1044 

  1045 This can be called at any time to override any current email settings (if 

  1046 they exist). However, new settings are only used by the MTM if they have been 

  1047 stored and then a new IMAP4 email session has been started: i.e. settings 

  1048 cannot be changed in mid-session.

  1049 

  1050 @param aSettings New IMAP4 service settings */

  1051     {

  1052     iImImap4Settings.CopyL(aSettings);

  1053     }

  1054 

  1055 EXPORT_C const CImImap4Settings& CImap4ClientMtm::Imap4Settings() const

  1056 /** Gets the IMAP4 email service settings currently being used by the client MTM, 

  1057 if they exist. 

  1058 

  1059 If no settings exist, then an empty settings object will be returned by this 

  1060 function. Settings will only exist if a prior call has been made to the RestoreL() 

  1061 function when the client MTM was positioned over an IMAP4 service in the message 

  1062 store.

  1063 

  1064 @return IMAP4 service settings */

  1065     {

  1066     return iImImap4Settings;

  1067     }

  1068 

  1069 //

  1070 // inherited from MUndoOffLine. This method is responsible for undoing

  1071 // an offline operation.

  1072 /**

  1073 This function is not supported.

  1074 

  1075 @param aDeleted Unused

  1076 @param aFolderId Unused

  1077 */

  1078 void CImap4ClientMtm::UndoOffLineChangesL(const CImOffLineOperation& /*aDeleted*/, TMsvId /*aFolderId*/)

  1079 //

  1080 // This method receives an offline operation struct the user wishes to cancel.

  1081 // The offline operation will already have been removed from the store of the

  1082 // folder. All that needs to be done is actually undo the operation itself.

  1083 // For instance, if an offline operation moved a message to another folder, this

  1084 // is the time to move the message back.

  1085 // This is probably best done by theserver dll, as the move has to be done without

  1086 // doing it on the remote server.

  1087 //

  1088     {

  1089     TODO//

  1090 

  1091     }

  1092 

  1093 //

  1094 // Returning a list of all the offline operations for a service entry.

  1095 

  1096 /**

  1097 @internalTechnology

  1098 */

  1099 

  1100 EXPORT_C CImOperationQueueList* CImap4ClientMtm::QueueListL(CMsvEntry& aServiceEntry)

  1101 	{

  1102 	return CImOperationQueueList::NewL(aServiceEntry, this);

  1103 	}

  1104 

  1105 void CImap4ClientMtm::AddAddresseeL(const TDesC& aRealAddress) 

  1106 /** Message address function required by the base class, but not used for IMAP. 

  1107 

  1108 To modify message address information, use the address functions in CImHeader.

  1109 

  1110 @param aRealAddress Address. */

  1111     {

  1112     __ASSERT_DEBUG(iAddresseeList != NULL, gPanic(EImpcNoAddresseeList));

  1113     iAddresseeList->AppendL(aRealAddress);

  1114     }

  1115 

  1116 void CImap4ClientMtm::AddAddresseeL(const TDesC& aRealAddress, const TDesC& aAlias) 

  1117 /** Message address function required by the base class, but not used for IMAP. 

  1118 

  1119 To modify message address information, use the address functions in CImHeader.

  1120 

  1121 @param aRealAddress Address.

  1122 @param aAlias Alias information. */

  1123     {

  1124 	 __ASSERT_DEBUG(iAddresseeList != NULL, gPanic(EImpcNoAddresseeList));

  1125 	HBufC* emailAddress = HBufC::NewLC(aRealAddress.Length()+aAlias.Length()+iEmailAddressFormatString->Length()-4);

  1126 	emailAddress->Des().Format(*iEmailAddressFormatString,&aAlias,&aRealAddress);

  1127 	iAddresseeList->AppendL(aRealAddress);

  1128 	CleanupStack::PopAndDestroy();	// emailAddress

  1129 	}

  1130 

  1131 void CImap4ClientMtm::RemoveAddressee(TInt aIndex) 

  1132 /** Message address function required by the base class, but not used for IMAP. 

  1133 

  1134 To modify message address information, use the address functions in CImHeader.