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 //

    15 

    16 #include "impspan.h"

    17 

    18 #include "impsmtm.h"

    19 #include <msventry.h>

    20 #include <imapset.h>

    21 #include <miutset.h>

    22 #include <offop.h>

    23 #include <msvreg.h>

    24 #include <imapcmds.h>

    25 #include <logwrap.h>

    26 #include <imcvutil.h>

    27 #include <cemailaccounts.h>

    28 

    29 #include "imapsess.h"

    30 #include "fldsync.h"

    31 #include "imapsync.h"

    32 #include "imapcomp.h"

    33 #include "imapoffl.h"

    34 #include "impsutil.h"

    35 

    36 #ifdef _DEBUG

    37 #define LOG_COMMANDS(a) iPrimarySession->iSession->LogText a

    38 #define DBG(a) a

    39 #define PRINTING

    40 #else

    41 #define LOG_COMMANDS(a)

    42 #define DBG(a)

    43 #undef PRINTING

    44 #endif

    45 

    46 // Type of MTM request: used only in this file

    47 enum

    48 	{

    49 	EMtmCopyToLocal=1,

    50 	EMtmMoveToLocal,

    51 	EMtmCopyFromLocal,

    52 	EMtmMoveFromLocal,

    53 	EMtmCopyWithinService,

    54 	EMtmMoveWithinService,

    55 	EMtmPopulate

    56 	};

    57 

    58 // Code for the active wrapper

    59 CActiveWrapper* CActiveWrapper::NewL(TInt aID)

    60 	{

    61 	CActiveWrapper* self=new(ELeave)CActiveWrapper(aID);

    62 	CleanupStack::PushL(self);

    63 	self->ConstructL();

    64 	CActiveScheduler::Add( self );

    65 	CleanupStack::Pop();

    66 	return self;

    67 	}

    68 

    69 CActiveWrapper::CActiveWrapper(TInt aID) : CActive(0), iID(aID)

    70 	{

    71 	}

    72 

    73 void CActiveWrapper::ConstructL()

    74 	{

    75 	// The object is a session

    76 	iSession=CImImap4Session::NewL(iID, *this);

    77 

    78 	// Get a compound operation

    79 	iCompound=CImImap4Compound::NewL(iSession);

    80 

    81 	// If we're the primary session, we get a fullsync object too

    82 	if (iID==1)

    83 		iFullSync=CImImap4Synchronise::NewL(iSession);

    84 	}

    85 

    86 void CActiveWrapper::StartL(MActiveWrapperObserver* aManager)

    87 	{

    88 	DBG((iSession->LogText(_L8("CActiveWrapper::StartL(ID=%d)"),iID)));

    89 

    90 	// The request has already been issued with our iStatus, so here all we

    91 	// do is note down the completion information and do a SetActive()

    92 	iParentPtr=aManager;

    93 	// Activate the observer as well, in case the request is cancelled.

    94 	iParentPtr->Activate();

    95 	SetActive();

    96 	}

    97 

    98 // Pointer to ActiveWrapper's iStatus, so direct commands to session (see above)

    99 // use the correct iStatus.

   100 TRequestStatus* CActiveWrapper::SessionStatus()

   101 	{

   102 	// Return the pointer

   103 	return(&iStatus);

   104 	}

   105 

   106 // Set entry pointers for classes the wrapper owns

   107 void CActiveWrapper::SetEntry(CMsvServerEntry* aEntry)

   108 	{

   109 	iSession->SetEntry(aEntry);

   110 	iCompound->SetEntry(aEntry);

   111 	if (iFullSync)

   112 		iFullSync->SetEntry(aEntry);

   113 	}

   114 

   115 void CActiveWrapper::DoCancel()

   116 	{

   117 	DBG((iSession->LogText(_L8("CActiveWrapper::DoCancel(ID=%d)"),iID)));

   118 

   119 	// Cancel anything we might have outstanding

   120 	if (iFullSync)

   121 		iFullSync->Cancel();

   122 	iCompound->Cancel();

   123 	if( !iSession->IsCancelling())

   124 		{

   125 		// Can only cancel the session if we're not waiting for a cancelled fetch

   126 		// to complete.

   127 		iSession->Cancel();	

   128 		}

   129 

   130 	// Tell parent we've completed: DON'T complete it ourselves.

   131 	iParentPtr->RequestCompleted(iID,KErrCancel);

   132 	}

   133 

   134 #ifdef PRINTING

   135 void CActiveWrapper::DoComplete(TInt aStatus)

   136 #else

   137 void CActiveWrapper::DoComplete(TInt /*aStatus*/)

   138 #endif

   139 	{

   140 	DBG((iSession->LogText(_L8("CActiveWrapper::DoComplete(%d, id=%d)"),aStatus,iID)));

   141 	}

   142 

   143 void CActiveWrapper::RunL()

   144 	{

   145 	// IMPORTANT: The contents of this CActiveWrapper::RunL() MUST NOT ever User::Leave()

   146 	DBG((iSession->LogText(_L8("ActiveWrapper RunL(ID=%d, result=%d)"),iID,iStatus.Int())));

   147 

   148 	TInt error=iStatus.Int();

   149 	Cancel(); // Obvious to do it here

   150 	iParentPtr->RequestCompleted(iID,error);

   151 	}

   152 

   153 CActiveWrapper::~CActiveWrapper()

   154 	{

   155 	Cancel();

   156 	delete iSession;

   157 	delete iCompound;

   158 	delete iFullSync;

   159 	}

   160 

   161 void CActiveWrapper::NonCompletedFailure()

   162 	{

   163 	DBG((iSession->LogText(_L8("ActiveWrapper::NonCompletedFailure (%d)"), iID)));

   164 

   165 	// A failure has occured on the session, but there is no outstanding asynchronous

   166 	// request on it. This can happen if for instance we get a disconnect while doing

   167 	// a cancel and idle operation. Pass the failure on to the parent.

   168 

   169 	iParentPtr->NonCompletedFailureOnSession(iID);

   170 	}

   171 

   172 // Return of current imap session

   173 CImImap4Session* CActiveWrapper::GetImap4Session()

   174 	{

   175 	return iSession;	

   176 	}

   177 

   178 // -----------------------------------------------------------------------

   179 

   180 // The actual MTM

   181 EXPORT_C CImap4ServerMtm* CImap4ServerMtm::NewL(CRegisteredMtmDll& aRegisteredMtmDll,CMsvServerEntry* aEntry)

   182 	{

   183 	CImap4ServerMtm* self=new CImap4ServerMtm(aRegisteredMtmDll,aEntry);

   184 	if (self==NULL)

   185 		{

   186 		aRegisteredMtmDll.ReleaseLibrary();

   187 		User::Leave(KErrNoMemory);

   188 		}

   189 	CleanupStack::PushL(self);

   190 	self->ConstructL();

   191 	CleanupStack::Pop();

   192 	return self;

   193 	}

   194 

   195 void CImap4ServerMtm::ConstructL()

   196 	{

   197 	// Make an Imap4 session: make it under the activewrapper, so we can have

   198 	// more than one at a time

   199 

   200 	// The primary session is the one that does the full sync

   201 	iPrimarySession=CActiveWrapper::NewL(1);

   202 

   203 	// The secondary session is used if we get fetch requests while the

   204 	// primary session is busy

   205 	iSecondarySession=CActiveWrapper::NewL(2);

   206 

   207 	// create an offline op controller

   208 	iOffLineControl=CImap4OffLineControl::NewL(iServerEntry, iPrimarySession->iSession);

   209 

   210 	// create the utils object

   211 	iUtils = CImap4Utils::NewL(iServerEntry);

   212 	

   213 	// tell the FullSync session about them

   214 	iPrimarySession->iFullSync->SetOffLineControl(iOffLineControl);

   215 	iPrimarySession->iFullSync->SetUtils(iUtils);

   216 

   217 	// Get an entry selection

   218 	iSelection=new (ELeave) CMsvEntrySelection;

   219 

   220 	// We're disconnected at first

   221 	iLastSessionState=TImap4GenericProgress::EDisconnected;

   222 

   223 	// We need to see invisible entries

   224 	TMsvSelectionOrdering invisible;

   225 	invisible=iServerEntry->Sort();

   226 	invisible.SetShowInvisibleEntries(ETrue);

   227 	iServerEntry->SetSort(invisible);

   228 

   229 	// Tell sessions and foldersync about it

   230 	iPrimarySession->SetEntry(iServerEntry);

   231 	iSecondarySession->SetEntry(iServerEntry);

   232 	}

   233 

   234 // MTM destructor: clean up - this involves removing the sessions.

   235 CImap4ServerMtm::~CImap4ServerMtm()

   236 	{

   237 	// We may still be active

   238 	Cancel();

   239 

   240 	// Ensure service is marked as offline (if the serviceid was initialised, anyway)

   241 	if (iServiceId && iServiceSettings)

   242 		{

   243 		// Make stuff invisible as necessary

   244 		TRAP_IGNORE(MarkOnOrOfflineL(EFalse));

   245 

   246 		// Get rid of settings

   247 		delete iServiceSettings;

   248 		}

   249 

   250 	// Clean up

   251 	delete iSelection;

   252 	delete iOneSelection;

   253 	delete iPrimarySession;

   254 	delete iSecondarySession;

   255 	delete iOffLineControl;

   256 	delete iUtils;

   257 	}

   258 

   259 // Do setentry, leave if there is an error

   260 void CImap4ServerMtm::SetEntryL(const TMsvId aId)

   261 	{

   262 	User::LeaveIfError(iServerEntry->SetEntry(aId));

   263 	}

   264 

   265 // Change entry, leave if error

   266 void CImap4ServerMtm::ChangeEntryL(const TMsvEntry& aEntry)

   267 	{

   268 	User::LeaveIfError(iServerEntry->ChangeEntry(aEntry));

   269 	}

   270 

   271 // Get children, leave if error

   272 void CImap4ServerMtm::GetChildrenL(CMsvEntrySelection& aSelection)

   273 	{

   274 	User::LeaveIfError(iServerEntry->GetChildren(aSelection));

   275 	}

   276 

   277 // remove an id, leave if error, moves to the parent first

   278 void CImap4ServerMtm::DeleteEntryL(TMsvId aId)

   279 	{

   280 	SetEntryL(aId);

   281 	SetEntryL(iServerEntry->Entry().Parent());

   282 	User::LeaveIfError(iServerEntry->DeleteEntry(aId));

   283 	}

   284 

   285 // Hierarchically make all folders visible/invisible: we go down until we can't

   286 // find any more folders, so this won't affect messages with subfolders.

   287 //

   288 // We don't use the bulk functions as we don't want to affect messages in the

   289 // folder, and we have to scan the entries to check for recursion anyway.

   290 void CImap4ServerMtm::ChangeVisibilityL(TMsvId aParent, TBool aInvisible)

   291 	{

   292 	ChangeVisibilityL(aParent, aInvisible, ETrue, KUidMsvFolderEntry);

   293 	}

   294 

   295 void CImap4ServerMtm::ChangeVisibilityL(TMsvId aParent, TBool aInvisible, TBool aRecurse, TUid aType)

   296 	{

   297 	DBG((iPrimarySession->iSession->LogText(_L8("ChangeVisibilityL(%x, %d)"),aParent,aInvisible)));

   298 

   299 	// Get children at this level

   300 	CMsvEntrySelection* selection=new (ELeave) CMsvEntrySelection;

   301 	CleanupStack::PushL(selection);

   302 

   303 	CMsvEntrySelection* folders=new (ELeave) CMsvEntrySelection;

   304 	CleanupStack::PushL(folders);

   305 

   306 	SetEntryL(aParent);

   307 	GetChildrenL(*selection);

   308 

   309 	if (selection->Count())

   310 		{

   311 		DBG((iPrimarySession->iSession->LogText(_L8("  Found %d children"),selection->Count())));

   312 

   313 		for(TInt child=0;child<selection->Count();child++)

   314 			{

   315 			// Move to this child

   316 			SetEntryL((*selection)[child]);

   317 			TMsvEntry message=iServerEntry->Entry();

   318 

   319 			DBG((iPrimarySession->iSession->LogText(_L8("  type %x visible %d"),message.iType,message.Visible())));

   320 			

   321 			// Is this the type we want to change?

   322 			if (message.iType==aType)

   323 				{

   324 				// Add to selection to do bulk change on, if necessary

   325 				if ((message.Visible() && aInvisible) ||

   326 					(!message.Visible() && !aInvisible))

   327 					{

   328 					DBG((iPrimarySession->iSession->LogText(_L8("  Adding %x to change list"),message.Id())));

   329 

   330 					folders->AppendL(message.Id());

   331 					}

   332 				}

   333 			

   334 			// Recurse downwards

   335 			if (aRecurse && message.iType==KUidMsvFolderEntry)

   336 				ChangeVisibilityL(message.Id(),aInvisible,aRecurse,aType);

   337 			}

   338 

   339 		// Change its visibility off all children if necessary

   340 		if (folders->Count())

   341 			{

   342 			// Do the change to the invisible flag (actual constant for the

   343 			// flag we want is private :( )

   344 			SetEntryL(aParent);

   345 			User::LeaveIfError(iServerEntry->ChangeAttributes(*folders,

   346 								aInvisible?0:KMsvVisibilityAttribute,

   347 								aInvisible?KMsvVisibilityAttribute:0));

   348 			}

   349 		}

   350 

   351 	// Release the service entry

   352 	SetEntryL(KMsvNullIndexEntryId);

   353 

   354 	// Get rid of selection

   355 	CleanupStack::PopAndDestroy(2);

   356 	}

   357 void CImap4ServerMtm::ClearNewFlagL(TMsvId aParent)

   358 	{

   359 	// Get children at this level

   360 	CMsvEntrySelection* selection=new (ELeave) CMsvEntrySelection;

   361 	CleanupStack::PushL(selection);

   362 	CMsvEntrySelection* msgs=new (ELeave) CMsvEntrySelection;

   363 	CleanupStack::PushL(msgs);

   364 	SetEntryL(aParent);

   365 	GetChildrenL(*selection);

   366 	// for each child

   367 	TInt count=selection->Count();

   368 	for(TInt child=0;child<count;child++)

   369 		{

   370 		SetEntryL((*selection)[child]);

   371 		TMsvEntry entry=iServerEntry->Entry();

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

   373 			msgs->AppendL(entry.Id());

   374 		// if this is a folder then recurse

   375 		if (entry.iType==KUidMsvFolderEntry)

   376 			ClearNewFlagL((*selection)[child]);

   377 		}

   378 	if (msgs->Count())// change attribute only when it has finished looking at all the children

   379 		{

   380 		SetEntryL(aParent);

   381 		User::LeaveIfError(iServerEntry->ChangeAttributes(*msgs,0,KMsvNewAttribute));

   382 		iPrimarySession->iSession->LogText(_L8("number of new msgs = (%d)"),msgs->Count());

   383 		}

   384 	CleanupStack::PopAndDestroy(2); // selection,msgs

   385 	}

   386 

   387 

   388 

   389 // Mark service as on or offline

   390 void CImap4ServerMtm::MarkOnOrOfflineL(const TBool aOnline)

   391 	{

   392 	// Mark service entry as on/offline	

   393 	SetEntryL(iServiceId);

   394 	TMsvEntry entry=iServerEntry->Entry();

   395 	entry.SetConnected(aOnline);

   396 	ChangeEntryL(entry);

   397 

   398 	// Release the service entry

   399 	SetEntryL(KMsvNullIndexEntryId);

   400 

   401 	// Going offline?

   402 	if (!aOnline && iServiceSettings->DisconnectedUserMode())

   403 		{

   404 		// We're an expert user going offline: don't touch anything

   405 		return;

   406 		}

   407 

   408 	// Mark all immediate children of the service as invisible

   409 	if (!aOnline)

   410 		ChangeVisibilityL(iServiceId,!aOnline);

   411 	}

   412 

   413 // Do the misc bits we need to when we've gone offline

   414 void CImap4ServerMtm::GoneOffline()

   415 	{

   416 	DBG((iPrimarySession->iSession->LogText(_L8("GoneOffline called"))));

   417 

   418 	// Cancel sessions: parking might be dangerous otherwise

   419 	iPrimarySession->Cancel();

   420 	iSecondarySession->Cancel();

   421 

   422 	// Park entries (in case a move entry has been left somewhere dangerous by a

   423 	// leave)

   424 	iPrimarySession->iSession->Park();

   425 	iSecondarySession->iSession->Park();

   426 

   427 	// Only do this is we have a valid service - we may not, due to being called

   428 	// both by the state machine and the progress entry

   429 	if (iServiceId)

   430 		{

   431 		// Offline, make folders invisible if we're not a disconnected mode user

   432 		TRAP_IGNORE(MarkOnOrOfflineL(EFalse));

   433 	

   434 		// Clear serviceid, it's not valid anymore

   435 		iServiceId=0;

   436 		}

   437 

   438 	// Settings can be dumped now

   439 	delete iServiceSettings;

   440 	iServiceSettings=NULL;

   441 

   442 	// We can now be deleted

   443 	iCanBeDeletedNow=ETrue;

   444 	}

   445 

   446 // Check selection: all entries should be of appropriate

   447 // type. Messages in this context means complete messages, not RFC888

   448 // parts of another message. parts means attachment or text

   449 // bodies. Make a local copy of valid entries

   450 

   451 TInt CImap4ServerMtm::CheckSelectionL(const CMsvEntrySelection& aSelection,

   452 									  CMsvEntrySelection* aLocalCopy,

   453 									  const TBool aMessages,

   454 									  const TBool aParts,

   455 									  const TBool aFolders,

   456 									  const TBool aIsInService)

   457 	{

   458 	// Reset copy selection

   459 	aLocalCopy->Reset();

   460 

   461 	// Check all entries are messages

   462 	for(TInt a=0;a<aSelection.Count();a++)

   463 		{

   464 		// Does entry exist?

   465 		TBool addIt = EFalse;

   466 

   467 		if (iServerEntry->SetEntry(aSelection[a])==KErrNone)

   468 			{

   469 			TUid type = iServerEntry->Entry().iType;

   470 			if ((aMessages && type==KUidMsvMessageEntry) ||

   471 				(aParts && (type==KUidMsvEmailTextEntry || type==KUidMsvAttachmentEntry || type==KUidMsvMessageEntry)) ||

   472 				(aFolders && type==KUidMsvFolderEntry))

   473 				{

   474 				TBool inEnclosingMessage=EFalse;

   475 

   476 				// Do we need to check if it's in the local service or

   477 				// if it is a complete message

   478 				if (aIsInService || (!aParts && type==KUidMsvMessageEntry))

   479 					{

   480 					// Work up the tree until we get to the service or the root

   481 					do

   482 						{

   483 						SetEntryL(iServerEntry->Entry().Parent());

   484 						if (iServerEntry->Entry().iType==KUidMsvMessageEntry)

   485 							inEnclosingMessage=ETrue;

   486 						}

   487 					while(iServerEntry->Entry().iType!=KUidMsvServiceEntry &&

   488 						  iServerEntry->Entry().Id()!=KMsvRootIndexEntryId);		

   489 	

   490 					// Are we at the service that this MTM referrs to?

   491 					// SJM: if offline iServiceId==0 so allow all

   492 					if (!aIsInService || iServiceId==0 || iServerEntry->Entry().Id()==iServiceId)

   493 						{

   494 						// it's OK if it is not a message type (in

   495 						// which case it has already been checked and

   496 						// passed) or it is not within an enclosing message

   497 						if (type!=KUidMsvMessageEntry || !inEnclosingMessage || aParts)

   498 							addIt = ETrue;

   499 						}

   500 					}

   501 				else

   502 					{

   503 					// Add to local copy

   504 					addIt = ETrue;

   505 					}

   506 				}

   507 			}

   508 

   509 		if (addIt)

   510 			aLocalCopy->AppendL(aSelection[a]);

   511 #ifdef _DEBUG

   512 		// UI shouldn't really be giving us bogus items so panic

   513 		else

   514 			gPanic(EInvalidMsvTypeToCommand);

   515 #endif

   516 		}

   517 

   518 	// Anything to do?

   519 	if (!aLocalCopy->Count())

   520 		{

   521 		// Nothing valid to work with

   522 		User::RequestComplete(iRequest,KErrNotSupported);

   523 		return(KErrNotSupported);

   524 		}

   525 	

   526 	// All OK, the selection isn't empty

   527 	return(KErrNone);

   528 	}

   529 

   530 // aId has been unsubscribed. If it has no visible child folders then

   531 // make it invisible and check its parent with the same test

   532 void CImap4ServerMtm::PropagateInvisibleFlagL(TMsvId aId)

   533 	{

   534 	DBG((iPrimarySession->iSession->LogText(_L8("PropagateInvisibleFlagL: 0x%x"), aId)));

   535 

   536 	// finish if we've reached the top

   537 	if (aId == KMsvRootIndexEntryId)

   538 		return;

   539 	

   540 	SetEntryL(aId);

   541 

   542 	// finish if we've reached a service

   543 	if (iServerEntry->Entry().iType == KUidMsvServiceEntry)

   544 		return;

   545 

   546 	// return if we've found a subscribed folder since we can't make

   547 	// it invisible

   548 	if (((TMsvEmailEntry)iServerEntry->Entry()).LocalSubscription())

   549 		return;

   550 	

   551 	// check the children of this unsubscribed folder

   552 	CMsvEntrySelection* selection=new (ELeave) CMsvEntrySelection;

   553 	CleanupStack::PushL(selection);

   554 

   555 	GetChildrenL(*selection);

   556 

   557 	TBool visible=EFalse;

   558 	for (TInt i=0; i < selection->Count(); i++)

   559 		{

   560 		SetEntryL((*selection)[i]);

   561 

   562 		// look for a visible folder

   563 		TMsvEmailEntry entry = (TMsvEmailEntry)iServerEntry->Entry();

   564 		if (entry.iType == KUidMsvFolderEntry && entry.Visible())

   565 			{

   566 			visible=ETrue;

   567 			break;

   568 			}

   569 		}

   570 	

   571 	CleanupStack::PopAndDestroy(); // selection

   572 

   573 	// if no child folders were visible then make this folder

   574 	// invisible and continue up

   575 	if (!visible)

   576 		{

   577 		SetEntryL(aId);

   578 		

   579 		// make this invisible

   580 		TMsvEntry entry = iServerEntry->Entry();

   581 		entry.SetVisible(EFalse);

   582 		ChangeEntryL(entry);

   583 

   584 		// go up

   585 		PropagateInvisibleFlagL(entry.Parent());

   586 		}

   587 	}

   588 

   589 // Simply change local subscription flag on a folder immediately: This is used

   590 // as opposed to ChangeL() as this operation can occur offline.

   591 

   592 // SJM: If SubscribeStrategy is UpdateRemote or UpdateBoth then doing

   593 // this should trigger a RemoteSubscription?

   594 

   595 TInt CImap4ServerMtm::SetLocalSubscription(const TMsvId aFolder, TBool aSubscribed)

   596 	{

   597 	TInt err;

   598 

   599 	// Move to the entry

   600 	if ((err=iServerEntry->SetEntry(aFolder))!=KErrNone)

   601 		return(err);

   602 

   603 	// Check it's a folder

   604 	if (iServerEntry->Entry().iType!=KUidMsvFolderEntry)

   605 		return(KErrNotSupported);

   606 

   607 	DBG((iPrimarySession->iSession->LogText(_L8("SetLocalSubscription: 0x%x %d"), aFolder, aSubscribed)));

   608 		

   609 	// Twiddle flag

   610 	TMsvEmailEntry entry=iServerEntry->Entry();

   611 	entry.SetLocalSubscription(aSubscribed);

   612 	return(iServerEntry->ChangeEntry(entry));

   613 	}

   614 

   615 

   616 // Perform a general move/copy function: this tidies up a lot of the Copy/Move

   617 // MTM specifics into one place

   618 void CImap4ServerMtm::MtmCommandL(const TInt aType,const CMsvEntrySelection& aSelection,

   619 								  TMsvId aDestination, TRequestStatus& aStatus)

   620 	{

   621 	iRequest=&aStatus;

   622 	// reset error code

   623 	iProgressErrorCode=KErrNone;

   624 	

   625 	// Is source remote? Ensure we check it's from our service

   626 	TBool checksource=ETrue;

   627 	if (aType==EMtmCopyFromLocal || aType==EMtmMoveFromLocal)

   628 		checksource=EFalse;

   629 

   630 	// we can only handle parts of messages on Populate

   631 	TBool handleParts=EFalse;

   632 	if (aType==EMtmPopulate||aType==EMtmCopyToLocal)

   633 		handleParts=ETrue;

   634 	

   635 	// Check selection contains messages, or maybe parts

   636 	if (CheckSelectionL(aSelection,iSelection,ETrue,handleParts,EFalse,checksource))

   637 		return;

   638 

   639 	// Save destination

   640 	iDestination=aDestination;

   641 

   642 	// Are we online?

   643 	if (!iPrimarySession->iSession->Connected())

   644 		{

   645 		iProgressMsgsToDo=iSelection->Count();

   646 		iProgressMsgsDone=0;

   647 

   648 		// set state for dorunl

   649 		switch(aType)

   650 			{

   651 		case EMtmCopyToLocal:			

   652 			iState=iSavedState=EMtmStateOffLineCopyToLocal;

   653 			iRequestedOperation=TImap4GenericProgress::EOffLineCopyToLocal;

   654 			break;

   655 

   656 		case EMtmCopyFromLocal:

   657 			iState=iSavedState=EMtmStateOffLineCopyFromLocal;

   658 			iRequestedOperation=TImap4GenericProgress::EOffLineCopyFromLocal;

   659 			break;

   660 

   661 		case EMtmCopyWithinService:

   662 			iState=iSavedState=EMtmStateOffLineCopyWithinService;

   663 			iRequestedOperation=TImap4GenericProgress::EOffLineCopyWithinService;

   664 			break;

   665 

   666 		case EMtmMoveToLocal:

   667 			iState=iSavedState=EMtmStateOffLineMoveToLocal;

   668 			iRequestedOperation=TImap4GenericProgress::EOffLineMoveToLocal;

   669 			break;

   670 

   671 		case EMtmMoveFromLocal:

   672 			iState=iSavedState=EMtmStateOffLineMoveFromLocal;

   673 			iRequestedOperation=TImap4GenericProgress::EOffLineMoveFromLocal;

   674 			break;

   675 

   676 		case EMtmMoveWithinService:

   677 			iState=iSavedState=EMtmStateOffLineMoveWithinService;

   678 			iRequestedOperation=TImap4GenericProgress::EOffLineMoveWithinService;

   679 			break;

   680 

   681 		case EMtmPopulate:

   682 			{

   683 			iState=iSavedState=EMtmStateOffLinePopulate;

   684 			iRequestedOperation=TImap4GenericProgress::EOffLinePopulate;

   685 			break;

   686 			}

   687 		default:

   688 			break;

   689 			}

   690 		TRequestStatus* pS=(&iStatus);

   691 		User::RequestComplete(pS,KErrNone);

   692 		SetActive();

   693 		}

   694 	else

   695 		{

   696 		TRequestStatus* status;

   697 

   698 		// Default to primary session

   699 		iCurrentSession=iPrimarySession;

   700 		status=iCurrentSession->SessionStatus();

   701 

   702 		// Initialise messages to do, etc

   703 		iProgressMsgsToDo=iSelection->Count();

   704 		iProgressMsgsDone=0;

   705 

   706 		switch(aType)

   707 			{

   708 		case EMtmPopulate:

   709 		case EMtmCopyToLocal:

   710 			// We're online: is the primary session busy?

   711  			if( iBackgroundSyncInProgress || iCurrentSession->iSession->IsCancelling() ||

   712  							 		iPrimarySession->iSession->Busy())

   713 				{

   714 				DBG((iPrimarySession->iSession->LogText(_L8("Primary session busy, using secondary"))));

   715 

   716 				// We'll have to use the secondary session

   717 				iCurrentSession=iSecondarySession;

   718 

   719 				// Is the secondary session connected?

   720 				if (!iCurrentSession->iSession->Connected())

   721 					{

   722 					DBG((iPrimarySession->iSession->LogText(_L8("Connecting secondary"))));

   723 

   724 					// We need to connect the secondary session before

   725 					// continuing with the fetch. Do it. The source message

   726 					// selection has been checked and stored in iSelection,

   727 					// so it should be safe until the connect goes through

   728 					// for later issue.

   729 					iState=EMtmStateSecondaryConnect;

   730 					iSavedState=aType == EMtmPopulate ? EMtmStatePopulate : EMtmStateCopyToLocal;

   731 

   732 					// Issue the connect

   733 					iCurrentSession->StartL(this);

   734 					status=iCurrentSession->SessionStatus();

   735 					// Providing the reference of primary session 

   736 					iCurrentSession->iSession->SetPrimarySession(iPrimarySession);

   737 					iCurrentSession->iSession->ConnectL(*status,iServiceId);

   738 					break;

   739 					}

   740 				else if( iCurrentSession->iSession->IsCancelling() )

   741 					{

   742 					// Opps! Cannot do the populate currently - server busy.

   743 					DBG((iPrimarySession->iSession->LogText(_L8("Secondary already cancelling"))));

   744 					

   745 					User::RequestComplete(iRequest,KErrServerBusy);

   746 					return;

   747 					}

   748 

   749 				DBG((iPrimarySession->iSession->LogText(_L8("Secondary already connected, reusing"))));

   750 				}

   751 

   752 			// Calculate the total size of the messages to be downloaded in this selection.

   753 			iTotalSize = iCurrentSession->iSession->CalculateDownloadSizeL(*iSelection);

   754 

   755 			// Select relevant folder

   756 			iCurrentSession->StartL(this);

   757 			status=iCurrentSession->SessionStatus();

   758 			iUtils->SetUpLogMessageL((*iSelection)[0]);

   759 			if (aType == EMtmPopulate)

   760 				{

   761 				iState = EMtmStatePopulate;

   762 				// compound need to know the number of msgs to suspend imap idle calls if > 1

   763 				if(iProgressMsgsToDo > 0)

   764 					{

   765 					iCurrentSession->iCompound->SetMessageCount(iProgressMsgsToDo);

   766 					}

   767 				DBG((iPrimarySession->iSession->LogText(_L8("CImapMTM::MTMCommandL(): Calling iCurrentSession->iCompound->Populate()"))));

   768  				iCurrentSession->iCompound->PopulateL(*status,(*iSelection)[0],iPartialMailInfo);

   769 				}

   770 			else

   771 				{

   772 				iState = EMtmStateCopyToLocal;

   773 				iCurrentSession->iCompound->CopyToLocalL(*status,(*iSelection)[0],iDestination);

   774 				}

   775 			break;

   776 

   777 		case EMtmMoveToLocal:

   778 			// We're online, are we busy? (it's a write op, and so we must use the

   779 			// primary session)

   780 			if( iBackgroundSyncInProgress || iCurrentSession->iSession->IsCancelling() )

   781 				{

   782 				// Can't do it, we're busy

   783 				User::RequestComplete(iRequest,KErrServerBusy);

   784 				return;

   785 				}

   786 

   787 			// Calculate the total size of the messages to be downloaded in this selection.

   788 			iTotalSize = iCurrentSession->iSession->CalculateDownloadSizeL(*iSelection);

   789 

   790 			// Select relevant folder

   791 			iCurrentSession->StartL(this);

   792 			iState=EMtmStateMoveToLocal;

   793 			iUtils->SetUpLogMessageL((*iSelection)[0]);

   794 			iCurrentSession->iCompound->MoveToLocalL(*status,(*iSelection)[0],iDestination);

   795 			break;

   796 

   797 		case EMtmCopyFromLocal:

   798 		case EMtmMoveFromLocal:

   799 

   800 			// As this is a write operation, is must be done on the primary session:

   801 			// is it free?

   802 			if( iBackgroundSyncInProgress || iCurrentSession->iSession->IsCancelling() )

   803 				{

   804 				// Can't do it

   805 				User::RequestComplete(iRequest,KErrServerBusy);

   806 				return;

   807 				}

   808 

   809 			// Calculate the total size of the messages to be downloaded in this selection.

   810 			iTotalSize = iCurrentSession->iSession->CalculateDownloadSizeL(*iSelection);

   811 

   812 			iState=(aType==EMtmCopyFromLocal)?EMtmStateCopyFromLocal:EMtmStateMoveFromLocal;

   813 

   814 

   815 			// Start the first operation

   816 			iCurrentSession->StartL(this);

   817 			if (aType==EMtmCopyFromLocal)

   818 				iCurrentSession->iCompound->CopyFromLocalL(*status,(*iSelection)[0],iDestination);

   819 			else

   820 				iCurrentSession->iCompound->MoveFromLocalL(*status,(*iSelection)[0],iDestination);

   821 			break;

   822 

   823 		case EMtmCopyWithinService:

   824 		case EMtmMoveWithinService:

   825 			// As this is a write operation, is must be done on the primary session:

   826 			// is it free?

   827 			if( iBackgroundSyncInProgress || iCurrentSession->iSession->IsCancelling() )

   828 				{

   829 				// Can't do it

   830 				User::RequestComplete(iRequest,KErrServerBusy);

   831 				return;

   832 				}

   833 

   834 			// Set the state, as we may be dealing with multiple entries

   835 			iState=(aType==EMtmCopyWithinService)?EMtmStateCopyWithinService:

   836 												  EMtmStateMoveWithinService;

   837 

   838 			// Do the copy with the compound

   839 			iCurrentSession->StartL(this);

   840 			if (aType==EMtmCopyWithinService)

   841 				iCurrentSession->iCompound->CopyWithinServiceL(*status,*iSelection,iDestination);

   842 			else

   843 				iCurrentSession->iCompound->MoveWithinServiceL(*status,*iSelection,iDestination);

   844 			break;

   845 			}

   846 		}

   847 	}

   848 

   849 

   850 // CopyToLocal fetches message parts into the mirror: aDestination is currently

   851 // not used. This is the only command which can cause the second session to

   852 // connect, as it is for fetching *only* (not 'modifiable' commands which may

   853 // cause the current synchronisation in the primary session to hiccup). This

   854 // also rules out MoveToLocal, as it involves a delete on the remote server.

   855 void CImap4ServerMtm::CopyToLocalL(const CMsvEntrySelection& aSelection,TMsvId aDestination, TRequestStatus& aStatus)

   856 	{

   857 	aStatus=KRequestPending;

   858 

   859 	LOG_COMMANDS((_L8("MTMCOMMAND CopyToLocal(%d items to %x)"),aSelection.Count(),aDestination));

   860 

   861 	iRequestedOperation=TImap4GenericProgress::ECopyToLocal;

   862 	iGetMailOptions=EGetImap4EmailBodyTextAndAttachments;

   863 	MtmCommandL(EMtmCopyToLocal,aSelection,aDestination,aStatus);

   864 	}

   865 

   866 // Move To Local moves a message from the remote server to a local folder:

   867 // this is performed as a fetch, then a delete on the remote server.

   868 void CImap4ServerMtm::MoveToLocalL(const CMsvEntrySelection& aSelection,TMsvId aDestination, TRequestStatus& aStatus)

   869 	{

   870 	aStatus=KRequestPending;

   871 

   872 	LOG_COMMANDS((_L8("MTMCOMMAND MoveToLocal(%d items to %x)"),aSelection.Count(),aDestination));

   873 

   874 	// We can't do a 'movetolocal' with the destination being the same as the

   875 	// source, as then the mirror will be out of sync. We must be moving to somewhere

   876 	// outside this service. Check this.

   877 	if (!iOffLineControl->IdIsLocalL(aDestination))

   878 		{

   879 		TRequestStatus* status=&aStatus;

   880 		User::RequestComplete(status,KErrNotSupported);

   881 		}

   882 	else

   883 		{

   884 		iRequestedOperation=TImap4GenericProgress::EMoveToLocal;

   885 		iGetMailOptions=EGetImap4EmailBodyTextAndAttachments;

   886 		MtmCommandL(EMtmMoveToLocal,aSelection,aDestination,aStatus);

   887 		}

   888 	}

   889 

   890 // CopyFromLocal appends entire messages in the mirror to the server.

   891 void CImap4ServerMtm::CopyFromLocalL(const CMsvEntrySelection& aSelection,TMsvId aDestination, TRequestStatus& aStatus)

   892 	{

   893 	aStatus=KRequestPending;

   894 

   895 	LOG_COMMANDS((_L8("MTMCOMMAND CopyFromLocal(%d items to %x)"),aSelection.Count(),aDestination));

   896 

   897 	iRequestedOperation=TImap4GenericProgress::ECopyFromLocal;

   898 	MtmCommandL(EMtmCopyFromLocal,aSelection,aDestination,aStatus);

   899 	}

   900 

   901 // Does a CopyFromLocal (ie, IMAP APPEND of the message), then deletes the local message

   902 // if it was sucessful.

   903 void CImap4ServerMtm::MoveFromLocalL(const CMsvEntrySelection& aSelection,TMsvId aDestination, TRequestStatus& aStatus)

   904 	{

   905 	aStatus=KRequestPending;

   906 

   907 	LOG_COMMANDS((_L8("MTMCOMMAND MoveFromLocal(%d items to %x)"),aSelection.Count(),aDestination));

   908 

   909 	iRequestedOperation=TImap4GenericProgress::EMoveFromLocal;

   910 	MtmCommandL(EMtmMoveFromLocal,aSelection,aDestination,aStatus);

   911 	}

   912 

   913 // CopyWithinService copies entire messages to other folders on the server, using

   914 // the IMAP COPY command.

   915 void CImap4ServerMtm::CopyWithinServiceL(const CMsvEntrySelection& aSelection,TMsvId aDestination, TRequestStatus& aStatus)

   916 	{

   917 	aStatus=KRequestPending;

   918 

   919 	LOG_COMMANDS((_L8("MTMCOMMAND CopyWithinService(%d items to %x)"),aSelection.Count(),aDestination));

   920 

   921 	iRequestedOperation=TImap4GenericProgress::ECopyWithinService;

   922 	MtmCommandL(EMtmCopyWithinService,aSelection,aDestination,aStatus);

   923 	}

   924 

   925 // MoveWithinService copies entire messages to other folders on the server, using

   926 // the IMAP COPY command, then deletes the original if the copy was sucessful,

   927 // so performing a move.

   928 void CImap4ServerMtm::MoveWithinServiceL(const CMsvEntrySelection& aSelection,TMsvId aDestination, TRequestStatus& aStatus)

   929 	{

   930 	aStatus=KRequestPending;

   931 

   932 	LOG_COMMANDS((_L8("MTMCOMMAND MoveWithinService(%d items to %x)"),aSelection.Count(),aDestination));

   933 

   934 	iRequestedOperation=TImap4GenericProgress::EMoveWithinService;

   935 	MtmCommandL(EMtmMoveWithinService,aSelection,aDestination,aStatus);

   936 	}

   937 

   938 void CImap4ServerMtm::UndeleteAllL(const CMsvEntrySelection& aSelection, TRequestStatus& aStatus)

   939 	{

   940 	aStatus = KRequestPending;

   941 	LOG_COMMANDS((_L8("MTMCOMMAND UndeleteAll(%d items)"),aSelection.Count()));

   942 	if(IsActive())

   943 		{

   944 		TRequestStatus* request = &aStatus;

   945 		User::RequestComplete(request,KErrImapServerBusy);

   946 		return;

   947 		}

   948 		

   949 	iRequest=&aStatus;

   950 	iProgressErrorCode=KErrNone;

   951 

   952 	// Check selection contains only messages in the service

   953 	if (CheckSelectionL(aSelection,iSelection,ETrue,EFalse,EFalse,ETrue))

   954 		return;

   955 

   956 	iRequestedOperation=TImap4GenericProgress::EOffLineUndelete;

   957 

   958 	iProgressMsgsToDo=iSelection->Count();

   959 	iProgressMsgsDone=0;

   960 	iState=iSavedState=EMtmStateOffLineUndelete;

   961 

   962 	TRequestStatus* pS=(&iStatus);

   963 	User::RequestComplete(pS,KErrNone);

   964 	SetActive();

   965 	}

   966 

   967 

   968 void CImap4ServerMtm::DeleteAllL(const CMsvEntrySelection& aSelection, TRequestStatus& aStatus)

   969 	{

   970 	aStatus=KRequestPending;

   971 

   972 	LOG_COMMANDS((_L8("MTMCOMMAND DeleteAll(%d items)"),aSelection.Count()));

   973 

   974 	iRequest=&aStatus;

   975 	// reset error code

   976 	iProgressErrorCode=KErrNone;

   977 

   978 	if (PruneMessages(aSelection))

   979 		// Was this call to DeleteAllL an instruction to delete local parts of a message ?

   980 		// If so then we don't need to continue.

   981 		return;

   982    

   983 	// Are we online?

   984 	if (!iPrimarySession->iSession->Connected())

   985 		{

   986 		// SJM: Surely we need something like...

   987 		// Check selection contains only messages - not folders

   988 		if (CheckSelectionL(aSelection,iSelection,ETrue,EFalse,EFalse,EFalse))

   989 			return;

   990 

   991 		iRequestedOperation=TImap4GenericProgress::EOffLineDelete;

   992 

   993 		iProgressMsgsToDo=iSelection->Count();

   994 		iProgressMsgsDone=0;

   995 		iState=iSavedState=EMtmStateOffLineDelete;

   996 

   997 		TRequestStatus* pS=(&iStatus);

   998 		User::RequestComplete(pS,KErrNone);

   999 		SetActive();

  1000 		}

  1001 	else

  1002 		{

  1003 		iRequestedOperation=TImap4GenericProgress::EDelete;

  1004 

  1005 		// We need to do this in the primary session: is it busy?

  1006 		if (iBackgroundSyncInProgress || iPrimarySession->iSession->IsCancelling() ||

  1007 		    iPrimarySession->iSession->Busy())

  1008 			{

  1009 			// It's busy, we can't do it

  1010 			User::RequestComplete(iRequest,KErrServerBusy);

  1011 			return;

  1012 			}

  1013 

  1014 		// Message or folder to delete?

  1015 		DBG((iPrimarySession->iSession->LogText(_L8("First is %x"),aSelection[0])));

  1016 

  1017 		SetEntryL(aSelection[0]);

  1018 		if (iServerEntry->Entry().iType==KUidMsvMessageEntry)

  1019 			{

  1020 			DBG((iCurrentSession->iSession->LogText(_L8("Delete message"))));

  1021 

  1022 			// Check selection contains only messages

  1023 			if (CheckSelectionL(aSelection,iSelection,ETrue,EFalse,EFalse,ETrue))

  1024 				return;

  1025 

  1026 			iProgressMsgsToDo=iSelection->Count();

  1027 			iProgressMsgsDone=0;

  1028 			// Select parent folder of message

  1029 			iCurrentSession=iPrimarySession;

  1030 			iState=iSavedState=EMtmStateDelete;

  1031 			TRequestStatus* status=iCurrentSession->SessionStatus();

  1032 			iCurrentSession->iCompound->DeleteL(*status,*iSelection);

  1033 			iCurrentSession->StartL(this);

  1034 			}

  1035 		else if (iServerEntry->Entry().iType==KUidMsvFolderEntry)

  1036 			{

  1037 			DBG((iCurrentSession->iSession->LogText(_L8("Delete folder"))));

  1038 

  1039 			// Check selection contains only folders

  1040 			if (CheckSelectionL(aSelection,iSelection,EFalse,EFalse,ETrue,ETrue))

  1041 				return;

  1042 

  1043 			// Delete folder

  1044 			iCurrentSession=iPrimarySession;

  1045 			iState=iSavedState=EMtmStateDeleteFolder;

  1046 			TRequestStatus* status=iCurrentSession->SessionStatus();

  1047 			iCurrentSession->iCompound->DeleteFolderL(*status,(*iSelection)[0]);

  1048 			iCurrentSession->StartL(this);

  1049 			}

  1050 		else

  1051 			gPanic(EDeleteOfUnknownType);

  1052 		}

  1053 	}

  1054 

  1055 // Create: make a folder or mailbox. Can only happen online

  1056 void CImap4ServerMtm::CreateL(TMsvEntry aNewEntry, TRequestStatus& aStatus)

  1057 	{

  1058 	LOG_COMMANDS((_L8("MTMCOMMAND Create(parent %x)"),aNewEntry.Parent()));

  1059 

  1060 	aStatus=KRequestPending;

  1061 	iRequest=&aStatus;

  1062 	// reset error code

  1063 	iProgressErrorCode=KErrNone;

  1064 

  1065 	// Creating a folder?

  1066 	if (aNewEntry.iType!=KUidMsvFolderEntry)

  1067 		{

  1068 		// No - illegal op

  1069 		User::RequestComplete(iRequest,KErrNotSupported);

  1070 		return;

  1071 		}

  1072 

  1073 	// Are we online and not busy?

  1074 	if( iBackgroundSyncInProgress || iPrimarySession->iSession->IsCancelling() )

  1075 		{

  1076 		User::RequestComplete(iRequest,KErrServerBusy);

  1077 		return;

  1078 		}

  1079 

  1080 	// Folder or mailbox?

  1081 	TBool isfolder=ETrue;

  1082 	if (((TMsvEmailEntry)aNewEntry).Mailbox())

  1083 		isfolder=EFalse;

  1084 

  1085 	// Use primary session: issue create folder command

  1086 	iState=EMtmStateCreateFolder;

  1087 	iCurrentSession=iPrimarySession;

  1088 	TRequestStatus* status=iCurrentSession->SessionStatus();

  1089 	iCurrentSession->iCompound->CreateL(*status,aNewEntry.Parent(),aNewEntry.iDetails,isfolder);

  1090 	iCurrentSession->StartL(this);

  1091 	}

  1092 

  1093 void CImap4ServerMtm::ChangeL(TMsvEntry aNewEntry, TRequestStatus& aStatus)

  1094 	{

  1095 	LOG_COMMANDS((_L8("MTMCOMMAND Change(%x)"),aNewEntry.Id()));

  1096 

  1097 	User::LeaveIfError(iServerEntry->SetEntry( aNewEntry.Id() ));

  1098 	User::LeaveIfError(iServerEntry->ChangeEntry( aNewEntry ));

  1099 

  1100 	iRequest=&aStatus;

  1101 	// reset error code

  1102 	iProgressErrorCode=KErrNone;

  1103 	

  1104 	User::RequestComplete(iRequest, KErrNone);

  1105 	}

  1106 

  1107 // SJM: Old ChangeL entry. used to be able to update flags as well as

  1108 // rename folder. Change to only rename folder as its not obvious how

  1109 // you'd pass the flags across

  1110 TBool CImap4ServerMtm::RenameFolderL(TMsvId aId, const TImap4RenameFolder& aRename)

  1111 	{

  1112 	LOG_COMMANDS((_L8("MTMCOMMAND RenameFolder(%x) to %S"),aId,&aRename.iNewName));

  1113 

  1114 	// Are we online and not busy?

  1115 	if( iBackgroundSyncInProgress || iPrimarySession->iSession->IsCancelling() )

  1116 		{

  1117 		User::RequestComplete(iRequest,KErrServerBusy);

  1118 		return EFalse;

  1119 		}

  1120 

  1121 	// Issue a rename command on this object

  1122 	iState=EMtmStateRenameFolder;

  1123 	iCurrentSession=iPrimarySession;

  1124 	TRequestStatus* status=iCurrentSession->SessionStatus();

  1125 	iCurrentSession->iCompound->RenameL(*status, aId, aRename.iNewName);

  1126 	return ETrue;

  1127 	}

  1128 

  1129 // id can be either the service or anything below it. If it is not the

  1130 // service then we move up the tree until we find the service.

  1131 void CImap4ServerMtm::LoadSettingsL(TMsvId aId)

  1132 	{

  1133 	// Old settings shouldn't be hanging about, but...

  1134 	if (iServiceSettings)

  1135 		{