// Copyright (c) 2004-2009 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:

//

#include "csendasmessage.h"

#include <u32std.h>

#include <mtclbase.h>

#include <msvuids.h>

#include <mtmuids.h>

#include <txtrich.h>

#include <mturutils.h>

#include "csendassender.h"

#include "csendassession.h"

#include "csendasattachment.h"

#include "csendasmtmmanager.h"

#include "sendasserverdefs.h"

#include "csendasactivecontainer.h"

#include "csendaseditwatcher.h"

#include "tsendasserverpanic.h"

// max index for incoming RMessage parameters

const TInt KSendAsMaxMessageIndex = 3;

CSendAsMessage* CSendAsMessage::NewL(CSendAsSession& aSession)

	{

	CSendAsMessage* self = new(ELeave) CSendAsMessage(aSession);

	return self;

	}

CSendAsMessage::~CSendAsMessage()

	{

	delete iSender;

	delete iClientMtm;

	delete iAttachment;

	}

CSendAsMessage::CSendAsMessage(CSendAsSession& aSession)

: iSession(aSession)

	{

	// the data members of iProgress are defined such that when they

	// are zero initialised (like being embedded in a C-Class) this is

	// the same as the default progress structure.

	}

/** Dispatch the subsession message to the correct handler.

The return value indicates to the owner session if we are doing an

asynchronous operation.  ETrue is async: EFalse is sync.

Errors can only be returned by leaving.  This method should be encapsulated

in a trap harness to prevent the server AO from leaving during a ServiceL.

@param	aMesasge

The IPC message.

@return

A value of true if the request is asynchronous, otherwise a value of false

indicating that the request is synchronous.

*/

TBool CSendAsMessage::DoSubSessionServiceL(const RMessage2& aMessage)

	{

	TBool async = EFalse;

	switch( aMessage.Function() )

		{

	case ESAMCreateForAccount:

		{

		CreateMessageForAccountL(aMessage);

		} break;

	case ESAMCreateByType:

		{

		CreateMessageByTypeL(aMessage);

		} break;

	case ESAMGetProgress:

		{

		ProgressL(aMessage);

		} break;

	case ESAMDelete:

		{

		DeleteMessageL(aMessage);

		} break;

	case ESAMSetBodyFirst:

		{

		SetBodyTextL(aMessage, ETrue);

		} break;

	case ESAMSetBodyNext:

		{

		SetBodyTextL(aMessage, EFalse);

		} break;

	case ESAMSetSubject:

		{

		SetSubjectL(aMessage);

		} break;

	case ESAMSetBioType:

		{

		SetBioTypeL(aMessage);

		} break;

	case ESAMAddRecipient:

		{

		AddRecipientL(aMessage);

		} break;

	case ESAMAddRecipientWithAlias:

		{

		AddRecipientWithAliasL(aMessage);

		} break;

	case ESAMTransferAttachmentFile:

		{

		TransferAttachmentFileL(aMessage);

		} break;

	case ESAMAddAttachment:

		{

		AddAttachmentL(aMessage);

		async = ETrue;

		} break;

	case ESAMAddAttachmentWithType:

		{

		AddAttachmentWithMimeTypeL(aMessage);

		async = ETrue;

		} break;

	case ESAMAddLinkedAttachment:

		{

		AddLinkedAttachmentL(aMessage);

		async = ETrue;

		} break;

	case ESAMAddLinkedAttachmentWithType:

		{

		AddLinkedAttachmentWithMimeTypeL(aMessage);

		async = ETrue;

		} break;

	case ESAMCreateAttachment:

		{

		// Message will complete upon transfering ownership of file to client.

		CreateAttachmentL(aMessage);

		async = ETrue;

		} break;

	case ESAMCreateAttachmentWithType:

		{

		// Message will complete upon transfering ownership of file to client.

		CreateAttachmentWithMimeTypeL(aMessage);

		async = ETrue;

		} break;

	case ESAMCancel:

		{

		Cancel();

		} break;

	case ESAMLaunchEditor:

		{

		LaunchEditorL(aMessage);

		} break;

	case ESAMSendMessageConfirmed:

		{

		async = ETrue;

		// drop through to next case...

		}

	case ESAMSendMessageConfirmedBackground:

		{

		SendMessageL(aMessage, ETrue, !async);

		} break;

	case ESAMSendMessage:

		{

		async = ETrue;

		// drop through to next case...

		}

	case ESAMSendMessageBackground:

		{

		SendMessageL(aMessage, EFalse, !async);

		} break;

	case ESAMSaveMessage:

		{

		__ASSERT_ALWAYS( iState == EMessageCreated, PanicClientL(aMessage, ESendAsClientPanicNoCurrentMessage));

		__ASSERT_DEBUG( iClientMtm != NULL, User::Invariant() );

		DoSaveMessageL();

		} break;

	case ESAMSetCharacterSet:

		{

		// For setting the charset encoding value for the message.

		SetMessageCharacterSetL(aMessage);	

		}break;

	case ESAMCharSetInfoForAttachment:

		{

		// For setting the charset encoding value for the message.

		SetCharsetInfoForAttachment(aMessage);	

		}break;

	default:

		PanicClientL(aMessage, ESendAsClientPanicBadRequest);

		break;

		}

	return async;

	}

/** Cancels any asynchronous activity being done by the message.

*/

void CSendAsMessage::CancelMessage()

	{

	// cancelling is a safe thing to do, like closing.

	switch( iState )

		{

	case EAddingOrCreatingAttachment:

		{

		__ASSERT_DEBUG( iAttachment != NULL, User::Invariant() );

		// cancel and then delete the attachment object.

		iAttachment->Cancel();

		delete iAttachment;

		iAttachment = NULL;

		} break;

	case ESendingMessage:

		{

		__ASSERT_DEBUG( iSender != NULL, User::Invariant() );

		// cancel and then delete the sender object.

		iSender->Cancel();

		delete iSender;

		iSender = NULL;

		} break;

	case EIdle:

	case EMessageCreated:

	case ESendingMessageComplete:

	case EMessageDeleted:

	case EPendingClose:

	default:

		// do nothing as cancel is a safe thing...

		break;		

		}

	}

/** Allocate a heap buffer to hold a descriptor parameter and copy it in.

This method leaves if the desciptor is not valid. This method pushes the buffer

onto the cleanup stack and leaves it there when it returns.

@param	aMessage

The IPC message.

@param	aIndex

The index of the parameter to read from the IPC message.

@return

A pointer to an array populated with the descriptor data. A copy of the pointer

is left on the cleanup stack.

*/

HBufC* CSendAsMessage::GetDesParamLC(const RMessage2& aMessage, TInt aIndex)

	{

	__ASSERT_DEBUG((aIndex >=0 && aIndex <=KSendAsMaxMessageIndex), PanicClientL(aMessage, ESendAsClientPanicBadRequestArgument));

	TInt len = User::LeaveIfError(aMessage.GetDesLength(aIndex));

	HBufC* buffer = HBufC::NewLC(len);

	TPtr ptr(buffer->Des());

	aMessage.Read(aIndex, ptr);

	return buffer;

	}

/** Allocate a heap buffer to hold a descriptor parameter and copy it in.

This method leaves if the desciptor is not valid. This method pushes the buffer

onto the cleanup stack and leaves it there when it returns.

@param	aMessage

The IPC message.

@param	aIndex

The index of the parameter to read from the IPC message.

@return

A pointer to an array populated with the descriptor data. A copy of the pointer

is left on the cleanup stack.

*/

HBufC8* CSendAsMessage::GetDesParam8LC(const RMessage2& aMessage, TInt aIndex)

	{

	__ASSERT_DEBUG((aIndex >=0 && aIndex <=KSendAsMaxMessageIndex), PanicClientL(aMessage, ESendAsClientPanicBadRequestArgument));

	TInt len = User::LeaveIfError(aMessage.GetDesLength(aIndex));

	HBufC8* buffer = HBufC8::NewLC(len);

	TPtr8 ptr(buffer->Des());

	aMessage.Read(aIndex, ptr);

	return buffer;

	}

/**

Create a message in the drafts folder and set up this CSendAsMessage instance to

operate on it.

This method requires either an MTM UID or a valid account ID. 

If the MTM UID is NULL, then the account ID must be valid otherwise the method will

leave. If the account ID is valid, then the MTM of the account is used.

@param	aMtm

The UID of the MTM for the new message.

@param	aAccount

The account ID under which the message is created.

@leave	KErrNotFound

The MTM UID is NULL and the account ID is not valid.

*/

void CSendAsMessage::DoCreateMessageL(TUid aMtm, TSendAsAccount aAccount)

	{

	// new context 

	CMsvEntry* msvEntry = CMsvEntry::NewL(iSession.GetMsvSessionL(), aAccount, TMsvSelectionOrdering());

	CleanupStack::PushL(msvEntry);

	if( aMtm == KNullUid )

		{

		if( aAccount == KMsvRootIndexEntryId || msvEntry->Entry().iType != KUidMsvServiceEntry )

			{

			// not a valid account

			User::Leave(KErrNotFound);

			}

		// get associated mtm uid

		aMtm = msvEntry->Entry().iMtm;

		}

	// create mtm by uid	

	DeleteClientMtm();

	iClientMtm = iSession.GetClientMtmL(aMtm);

	// if no account provided, get default for this MTM

	if( aAccount == KMsvRootIndexEntryId )

		{

		aAccount = iClientMtm->DefaultServiceL();

		}

	// create message in drafts folder

	msvEntry->SetEntryL(KMsvDraftEntryId);

	// mtm takes ownership of entry context	

	CleanupStack::Pop(msvEntry);

	iClientMtm->SetCurrentEntryL(msvEntry);

	// create message

	iClientMtm->CreateMessageL(aAccount);

	iMessageType = aMtm;

	// Change the context of the client MTM to the newly created message entry

	iClientMtm->SwitchCurrentEntryL(iClientMtm->Entry().EntryId());

	// Load the message created so far into the client MTMs cache. This ensures

	// that SendAs will not overwrite any body text added during the

	// CreateMessageL routine (such as signature text).

	// Some MTMs don't actually write anything to store during the

	// CreateMessageL phase, so the LoadMessageL can leave with KErrNotFound.

	// It is safe to trap and ignore this as it just means there is no message

	// body text to be loaded.

	TRAPD(err, iClientMtm->LoadMessageL());

	if (err != KErrNone && err != KErrNotFound)

		{

		User::Leave(err);

		}

	iState = EMessageCreated;

	}

/** Create a new message in the drafts folder, using the specified account.

The account to use is passed from the client in a package buffer, held in

parameter 0 of the message.

@param	aMessage

The IPC message.

*/

void CSendAsMessage::CreateMessageForAccountL(const RMessage2& aMessage)

	{

	__ASSERT_ALWAYS( iState == EIdle, PanicClientL(aMessage, ESendAsClientPanicSubsessionInUse) );

	TPckgBuf<TSendAsAccount> accountBuf;

	aMessage.Read(0, accountBuf);

	DoCreateMessageL(KNullUid, accountBuf()); 

	}

/** Create a new message in the drafts folder, of the specified type.

The message type (a TUid) to create is passed from the client in a package buffer,

held in parameter 0 of the message.

@param	aMessage

The IPC message.

*/

void CSendAsMessage::CreateMessageByTypeL(const RMessage2& aMessage)

	{

	__ASSERT_ALWAYS( iState == EIdle, PanicClientL(aMessage, ESendAsClientPanicSubsessionInUse) );

	// extract mtm uid

	TPckgBuf<TUid> uidBuf;

	aMessage.Read(0, uidBuf);

	// create message using default account for this mtm

	DoCreateMessageL(uidBuf());

	}

/** Delete the open message from the drafts folder.

@param aMessage

The IPC message.

*/

void CSendAsMessage::DeleteMessageL(const RMessage2& aMessage)

	{

	// Client code should cancel any outstanding requests prior to deleting

	// the message. Failure to do so will result in the client being panicked.

	switch (iState)

		{

	case EMessageCreated:

		{

		__ASSERT_DEBUG( iClientMtm != NULL, User::Invariant() );

		iClientMtm->Session().RemoveEntry(iClientMtm->Entry().EntryId());

		iState = EMessageDeleted;

		} break;

	case EIdle:

	case ESendingMessageComplete:

	case EPendingClose:

		break;

	case ESendingMessage:

		{

		PanicClientL(aMessage, ESendAsClientPanicSendingMessage);

		} break;

	case EAddingOrCreatingAttachment:

		{

		PanicClientL(aMessage, ESendAsClientPanicAddingCreatingAttachment);

		} break;

	case EMessageDeleted:

	default:

		PanicClientL(aMessage, ESendAsClientPanicMessageAlreadyDeleted);

		break;

		}

	DeleteClientMtm();

	}

/** Set the body text of the open message.

The body text is specified using a CRichText object. This object is streamed 

into a descriptor which is passed over the IPC boundary in parameter 0 of the

message. The CRichText object is then internalised by the server.

@param	aMessage

The IPC message.

@param	aFirstChunk

A flag that indicates whether this is the first chunk of rich text received 

from the client.

*/

void CSendAsMessage::SetBodyTextL(const RMessage2& aMessage, TBool aFirstChunk)

	{

	__ASSERT_ALWAYS( iState == EMessageCreated, PanicClientL(aMessage, ESendAsClientPanicNoCurrentMessage) );

	__ASSERT_DEBUG( iClientMtm != NULL, User::Invariant() );

	TInt response = 0;

	User::LeaveIfError(iClientMtm->QueryCapability(KUidMtmQuerySupportedBody, response));

	// This location in the body text at which the text is to be inserted.

	TInt insertLoc = 0;

	if( aFirstChunk )

		{

		// Store the size of the signature text. This is added to the body

		// text on creation of the message by the client MTM.

		// All added body text is to be added before the signature text.

		iSignatureSize = iClientMtm->Body().DocumentLength();

		}

	else

		{

		// insert added text before the signature text.

		insertLoc = iClientMtm->Body().DocumentLength() - iSignatureSize;

		}

	TInt chunkLength = User::LeaveIfError(aMessage.GetDesLength(0));

	HBufC* textBuffer = GetDesParamLC(aMessage, 0);

	// Append the next chunk to the mtm's CRichText object.

	TRAPD(insertError, iClientMtm->Body().InsertL(insertLoc, *textBuffer));

	if( insertError != KErrNone )

		{

		iClientMtm->Body().Reset();

		User::Leave(insertError);

		}

	CleanupStack::PopAndDestroy(textBuffer);

	}

/** Set the subject of the open message.

The subject is plain text, held in a descriptor passed in parameter 0 of the

message.

@param	aMessage

The IPC message.

*/

void CSendAsMessage::SetSubjectL(const RMessage2& aMessage)

	{

	__ASSERT_ALWAYS( iState == EMessageCreated, PanicClientL(aMessage, ESendAsClientPanicNoCurrentMessage) );

	__ASSERT_DEBUG( iClientMtm != NULL, User::Invariant() );

	HBufC* subject = GetDesParamLC(aMessage, 0);

	iClientMtm->SetSubjectL(*subject);

	CleanupStack::PopAndDestroy(subject);

	}

/** Set the BIO type of the message.

The BIO type is passed from the client in a package buffer, pointed to by 

parameter 0 of the message.

@param	aMessage

The IPC message.

*/

void CSendAsMessage::SetBioTypeL(const RMessage2& aMessage)

	{

	__ASSERT_ALWAYS( iState == EMessageCreated, PanicClientL(aMessage, ESendAsClientPanicNoCurrentMessage) );

	__ASSERT_DEBUG( iClientMtm != NULL, User::Invariant() );

	TPckgBuf<TUid> uidBuf;

	aMessage.Read(0, uidBuf);

	iClientMtm->BioTypeChangedL(uidBuf());