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

// All rights reserved.

// This component and the accompanying materials are made available

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

// which accompanies this distribution, and is available

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

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// Internet SMTP Transport Driver

// 

//

#include <msvstd.h>		// TMsvEntry, CMsvEntrySelection

#include <msventry.h>	// CMsvServerEntry

#include <msvstore.h>	// needed for CMsvStore::~CMsvStore

#include <imcvsend.h>	// CImSendConvert

#include "IMSM.H"		

#include "IMSMSEND.H"	

#include "SMTSUTIL.H"	// forward declarations for utility fns

#include "csmtpsessionmanager.h"

#include "csmtpsettings.h"

#include "cimmobilitymanager.h"

#if (defined SYMBIAN_USER_PROMPT_SERVICE)

#include "csmtpupsresponsewaiter.h"

#endif

const TInt KBccArraySegment  = 100; 

const TUid KUidSmtpServerMtm = {0x10003C79};

/**

Constructor

@param aEntrySelection Selection of messages to send

@param aServerEntry SMTP server entry

*/

CMsgImOutboxSend::CMsgImOutboxSend(const CMsvEntrySelection& aEntrySelection,CMsvServerEntry& aServerEntry)

        : CActive(KMsgImOutboxSendPriority), iEntrySelection(aEntrySelection),iServerEntry(aServerEntry)

	{

	}

/**

Factory constructor

@param aEntrySelection Selection of messages to send

@param aServerEntry SMTP server entry

@param aService SMTP service ID

@return Constructed class

*/

CMsgImOutboxSend* CMsgImOutboxSend::NewLC(const CMsvEntrySelection& aEntrySelection,CMsvServerEntry& aServerEntry, TMsvId aService)

	{

	CMsgImOutboxSend* self = new (ELeave) CMsgImOutboxSend(aEntrySelection,aServerEntry);

	CleanupStack::PushL(self);

	self->ConstructL(aService);

	return self;

	}

/**

Factory constructor

@param aEntrySelection Selection of messages to send

@param aServerEntry SMTP server entry

@param aService SMTP service ID

@return Constructed class

*/

CMsgImOutboxSend* CMsgImOutboxSend::NewL(const CMsvEntrySelection& aEntrySelection,CMsvServerEntry& aServerEntry, TMsvId aService)

	{

	CMsgImOutboxSend* self=CMsgImOutboxSend::NewLC(aEntrySelection,aServerEntry,aService);

	CleanupStack::Pop();

	return self;

	}

void CMsgImOutboxSend::ConstructL(TMsvId aService)

	{

	iTotalMessages = iEntrySelection.Count();

    iCurrentMessageNo = -1;

	iProgress.SetServiceId(aService);

	//Load service info iServerEntry context..

	User::LeaveIfError(iServerEntry.SetEntry(aService));	

	__ASSERT_DEBUG(iServerEntry.Entry().iType==KUidMsvServiceEntry,gPanic(EImsmNoServiceInfo));	//	Assert is ServiceEntry..	

	iSettings = CSmtpSettings::NewL(iServerEntry);

	iBccRcptArray = new (ELeave) CDesCArrayFlat(KBccArraySegment);

	//	Assert descriptors != empty

	__ASSERT_DEBUG (iSettings->ServerAddress().Length() >0 , gPanic(EImsmEmptyPostOffice));

	__ASSERT_DEBUG (iSettings->EmailAddress().Length()   >0 , gPanic(EImsmEmptyEmailAddress));

#if (defined SYMBIAN_USER_PROMPT_SERVICE)	

	iWaiter = CSmtpUpsResponseWaiter::NewL();

#endif

	if (iSettings->BearerMobility())

		{

		iMobilityManager = CImMobilityManager::NewL(KUidSmtpServerMtm, aService, *this);

		}

	CActiveScheduler::Add(this);

	}

#if (defined SYMBIAN_USER_PROMPT_SERVICE)	

void CMsgImOutboxSend::StartL(TRequestStatus& aStatus, TThreadId aClientThreadId, TBool aHasCapability) 

	{

	SetupStartL();

	iState = EStateUserPrompting;

	iWaiter->AuthoriseAndConnectL(iSettings->SmtpSettings(), aHasCapability, aClientThreadId, iStatus);

	SetActive();

	aStatus = KRequestPending;

	iReport = &aStatus;

	}

#endif

void CMsgImOutboxSend::StartL(TRequestStatus& aStatus) 

	{

	SetupStartL();

	StartConnectingL();

	aStatus = KRequestPending;

	iReport = &aStatus;

	}

void CMsgImOutboxSend::SetupStartL()

	{

	iSetDisconnected=EFalse;

	//	Get count messages.. leave if none.

	if (iTotalMessages == 0)

		{

		//	No messages leave..

		User::Leave(KErrEof);			

		}

	//  Set the connected flag messages..

	User::LeaveIfError(iServerEntry.SetEntry(KMsvGlobalOutBoxIndexEntryIdValue));

	User::LeaveIfError(iServerEntry.ChangeAttributes( iEntrySelection, KMsvConnectedAttribute, 0));

	iServerEntry.SetEntry(KMsvNullIndexEntryId);

	//	Initialise the progress object..Create and start a new sesion..

	iProgress.InitialiseTotal(iTotalMessages);	//	Sets status=EMsgOutboxProgressWaiting etc.

	iProgress.SetStatus(EMsgOutboxProgressConnecting);

	iProgress.SetMsgNo(-1);

	iCurrentMessageNo = -1;

	}

void CMsgImOutboxSend::StartConnectingL()

	{

	iState = EStateConnectingSession;

	iMobilityOperation = EMobilityOperationIdle;

	iSession = NULL;

	if (!iSessionManager)

		{

		iSessionManager = CSmtpSessionManager::NewL(iMobilityManager, iProgress.ServiceId());

		}

	iSessionManager->GetSessionL(iServerEntry, *iSettings, iSession, iStatus);

	SetActive();

	}

/**

A bearer switch has been requested and we should try to switch over to it.

The action parameter indicates what should happen to the current operation.

@param aAction What should happen to the current operation.

@param aIsSeamless Is this a seamless switchover.

*/

void CMsgImOutboxSend::PrepareForNewCarrier(TImMobilityAction aAction, TBool /*aIsSeamless*/)

	{

	switch (aAction)

		{

		case KAcceptImmediately:

			{

			// Just kill the current operation, and then signal that we are

			// ready to migrate

			CarrierLost();

			SignalMigrate();

			break;

			}

		case KAcceptStopCurrent:

			{

			PrepareForNewCarrierAfterOperation(EMobilityOperationStoppingCurrent);

			break;

			}

		case KAcceptCompleteCurrent:

			{

			PrepareForNewCarrierAfterOperation(EMobilityOperationCompletingCurrent);

			break;

			}

		default:

			{

			__ASSERT_DEBUG(EFalse, gPanic(EImsmUnexpectedMobilityAction));

			break;

			}

		}

	}

/**

A bearer switch has been requested and the current bearer should be dropped

immediately.

*/

void CMsgImOutboxSend::CarrierLost()

	{

	switch (iState)

		{

		case EStateIdle:

		case EStateWaitingNewCarrier:

		case EStateMobilityError:

			{

			// do nothing

			break;

			}

		case EStateConnectingSession:

			{

			CancelForMigrate();

			StartWaitingNewCarrier();

			break;

			}

		case EStateSendingFiles:

			{

			CancelForMigrate();

			delete iSession;

			iSession = NULL;

			StartWaitingNewCarrier();

			break;

			}

		case EStateClosingSession:

			{

			CancelForMigrate();

			// If we have stopped the current operation and there are still some

			// messages left to send then we need to wait for the migration to

			// occur.

			// If we have completed the operation, or we have sent all the messages

			// then we need to exit now. We do this by pretending that no bearer

			// migration is currently taking place, and self completing. Execution

			// will then pass to the RunL which will just assume that the session

			// has closed at the end of the operation and we will then exit.

			if (PreparingForMigration() && iCurrentMessageNo < iTotalMessages)

				{

				StartWaitingNewCarrier();

				}

			else

				{

				iMobilityOperation = EMobilityOperationIdle;

				TRequestStatus* status = &iStatus;

				User::RequestComplete(status, KErrNone);

				SetActive();

				}

			break;

			}

		case EStateUserPrompting:

		default:

			{

			__ASSERT_DEBUG(EFalse, gPanic(EImsmUnexpectedState2));

			break;

			}

		}

	}

/**

The new bearer is now active. Try to start using it.

@param aNewAp New access point

@param aIsSeamless Is this a seamless switchover

*/

void CMsgImOutboxSend::NewCarrierActive(TAccessPointInfo /*aNewAp*/, TBool /*aIsSeamless*/)

	{

	if (iState == EStateWaitingNewCarrier)

		{

		// Self complete to get the active object running again

		TRequestStatus* status = &iStatus;

		User::RequestComplete(status, KErrNone);

		}

	else

		{

		if (iMobilityManager)

			{

			iMobilityManager->NewCarrierAccepted();

			}

		}

	}

/**

An error has occured during a bearer mobility switch

@param aError Error code

*/

void CMsgImOutboxSend::MobilityError(TUint /*aError*/)

	{

	CancelForMigrate();

	TInt err = KErrNone;

	// If the mobility error has occurred when we are closing the connection

	// after sending all the messages then we can just self complete to make

	// it look like the session close completed successfully.

	// If the mobility error occurs in other states, or while closing the

	// session for a migration, then we should self complete with an error

	// so that the RunL routine cleans up and exits.

	if ((iState != EStateClosingSession) ||

	    (PreparingForMigration() && iCurrentMessageNo < iTotalMessages))

		{

		err = KErrDisconnected;	

		}

	iMobilityOperation = EMobilityOperationIdle;

	iState = EStateMobilityError;

	// Self complete with error code

	TRequestStatus* status = &iStatus;

	User::RequestComplete(status, err);

	SetActive();

	}

/**

Get progress information for mobility plugin

@return Packaged progress information

*/

const TDesC8& CMsgImOutboxSend::MobilityProgress()

	{

	iMobilityProgressBuffer = Progress();

	return iMobilityProgressBuffer;

	}

/**

A bearer switch has been requested and we should either stop the current

operation or complete it before indicating that the migration can proceed.

@param aMobilityOperation Type of mobility operation that has been requested

*/

void CMsgImOutboxSend::PrepareForNewCarrierAfterOperation(TMobilityOperation aMobilityOperation)

	{

	switch (iState)

		{

		case EStateIdle:

		case EStateWaitingNewCarrier:

		case EStateMobilityError:

			{

			SignalMigrate();

			break;

			}

		case EStateConnectingSession:

			{

			CancelForMigrate();

			SignalMigrate();

			StartWaitingNewCarrier();

			break;

			}

		case EStateSendingFiles:

		case EStateClosingSession:

			{

			// Just need to store what mobility operation has been requested.

			// Note that if we are sending files, the file sending operation will

			// see this and halt at the requested time.

			iMobilityOperation = aMobilityOperation;

			break;

			}

		case EStateUserPrompting:

		default:

			{

			__ASSERT_DEBUG(EFalse, gPanic(EImsmUnexpectedState1));

			break;

			}

		}

	}

void CMsgImOutboxSend::RunL()

	{

	TInt status = iStatus.Int();

	if (status == KErrNone)

		{

		switch (iState)

			{

			case EStateUserPrompting:

				{

				StartConnectingL();

				break;

				}

			case EStateConnectingSession:

				{

				SessionConnectedL();

				break;

				}

			case EStateSendingFiles:

				{

				SentFiles();

				break;

				}

			case EStateClosingSession:

				{

				SessionClosed();

				break;

				}

			case EStateWaitingNewCarrier:

				{

				MigratedL();

				break;

				}

			case EStateMobilityError:

				{

				// A mobility error occurred while we were closing the session after

				// sending all the messages.

				// do nothing

				break;

				}

			default:

				{

				__ASSERT_DEBUG(EFalse, gPanic(EImsmUnexpectedState3));

				break;

				}

			}

		}

	else

		{

		switch (iState)

			{

			case EStateUserPrompting:

				{

				// do nothing

				break;

				}

			case EStateConnectingSession:

				{

				SessionConnectionFailed();

				break;

				}

			case EStateSendingFiles:

				{

				// closing Session with server 	

				SentFiles();

				break;

				}

			case EStateClosingSession:

				{

				// Failure to close a session can be ignored as it will have been

				// tidied up.

				// Continue by assuming the close was successful.

				SessionClosed();

				break;

				}

			case EStateMobilityError:

				{

				// do nothing

				break;

				}

			case EStateWaitingNewCarrier:

			default:

				{

				__ASSERT_DEBUG(EFalse, gPanic(EImsmUnexpectedState4));

				}

			}

		}

	// If we are not active then this means we should complete

	if (!IsActive())

		{

		if (iSession)

			{

			iProgress.iSendFileProgress = iSession->FileProgress();

			}

		else

			{

			iProgress.iSendFileProgress.iSessionState = EClosingSmtp;

			iProgress.iSendFileProgress.iBytesSent = 0;

			iProgress.iSendFileProgress.iBytesToSend = 0;

			}

		Complete(status);

		}

	}

/**

Handles leaves during RunL

@param aError Error code

*/

TInt CMsgImOutboxSend::RunError(TInt aError)

	{

	switch (iState)

		{

		case EStateConnectingSession:

			{

			if (iMobilityOperation != EMobilityOperationMigrating)

				{

				iProgress.iSendFileProgress.iSessionState = EConnectingToSmtp;

				iProgress.iSendFileProgress.iBytesSent = 0;

				iProgress.iSendFileProgress.iBytesToSend = 0;

				iProgress.SetMsgNo(KErrNotFound);

				iProgress.SetConnectionIAP(KErrNotFound);

				}

			break;

			}

		case EStateSendingFiles: