// 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 <rsendasmessage.h>

#include <s32mem.h>

#include <txtrich.h>

#include "sendasserverdefs.h"

// Large enough to pass an sms message across in one transfer.

const TInt KSendAs2BodyChunkSize = 512;

/**

Create a new message in the Drafts folder.

The message type is implied by the type of the account used.

The message can be modified or deleted by this object at any

time up until the message is sent, deleted or opened in an editor.

@param	aSendAs

The connection to the SendAs server.  This RSendAs object must be

connected.

@param	aAccount

An account obtained from the CSendAsAccounts helper class.

*/

EXPORT_C void RSendAsMessage::CreateL(RSendAs& aSendAs, TSendAsAccount aAccount)

	{

	// create subsession with server.

	User::LeaveIfError(CreateSubSession((RSessionBase&)aSendAs, ESASCreateSubSession));

	TPckgBuf<TSendAsAccount> buf(aAccount);

	TInt createStatus = SendReceive(ESAMCreateForAccount, TIpcArgs(&buf));

	if (createStatus != KErrNone)

		{

		CloseSubSession(ESAMDestroySubSession);

		User::Leave(createStatus);

		}

	}

/**

Create a new message in the Drafts folder.

The message type is specified.

The message can be modified or deleted by this object at any

time up until the message is sent, deleted or opened in an editor.

@param aSendAs

The connection to the SendAs server.  This RSendAs object must be

connected.

@param aMessageType

A message type obtained from the CSendAsMessageTypes helper class.

*/

EXPORT_C void RSendAsMessage::CreateL(RSendAs& aSendAs, TUid aMessageType)

	{

	// create subsession with server

	User::LeaveIfError(CreateSubSession((RSessionBase&)aSendAs, ESASCreateSubSession));

	TPckgBuf<TUid> buf(aMessageType);

	TInt createStatus = SendReceive(ESAMCreateByType, TIpcArgs(&buf));

	if (createStatus != KErrNone)

		{

		CloseSubSession(ESAMDestroySubSession);

		User::Leave(createStatus);

		}

	}

/**

Close an open message and save it in the Drafts folder.

*/

EXPORT_C void RSendAsMessage::SaveMessageAndCloseL()

	{

	User::LeaveIfError(SendReceive(ESAMSaveMessage, TIpcArgs()));

	CloseSubSession(ESAMDestroySubSession);

	}

/**

Close an open message and delete it from the Drafts folder.

*/

EXPORT_C void RSendAsMessage::Close()

	{

	if (SubSessionHandle() != KNullHandle)

		{

		// don't attempt deletion if no subsession present (ie already closed/never opened)

		SendReceive(ESAMDelete, TIpcArgs());

		}

	CloseSubSession(ESAMDestroySubSession);

	}

/**

Set the body text of this message using a CRichText object.

The object must have an open message to use this method.

@param aBody

A CRichText object containing the body to add to the message being constructed.

*/

EXPORT_C void RSendAsMessage::SetBodyTextL(const CRichText& aBody)

	{

	TInt textLength = aBody.DocumentLength();

	TInt textPos = 0;

	HBufC* bodyBuf = HBufC::NewLC(KSendAs2BodyChunkSize);

	TPtr bodyPtr(bodyBuf->Des());

	while (textPos < textLength)

		{

		aBody.Extract(bodyPtr, textPos, KSendAs2BodyChunkSize);

		User::LeaveIfError(SendReceive(

			textPos == 0 ? ESAMSetBodyFirst : ESAMSetBodyNext, TIpcArgs(&bodyPtr)));

		textPos	+= KSendAs2BodyChunkSize;

		}

		CleanupStack::PopAndDestroy(bodyBuf);

	}

/**

Set the body text of this message using a plain descriptor.

The object must have an open message to use this method.

@param aBody

A descriptor containing the body to add to the message being constructed.

*/

EXPORT_C void RSendAsMessage::SetBodyTextL(const TDesC& aBody)

	{

	TInt textLength = aBody.Length();

	TInt textPos = 0;

	while (textPos < textLength)

		{

		TInt sizeLeft = textLength - textPos;

		TPtrC bodyPtr(aBody.Mid(textPos, 

			(KSendAs2BodyChunkSize >= sizeLeft) ? sizeLeft : KSendAs2BodyChunkSize));

		User::LeaveIfError(SendReceive(

			textPos == 0 ? ESAMSetBodyFirst : ESAMSetBodyNext, TIpcArgs(&bodyPtr)));

		textPos	+= KSendAs2BodyChunkSize;

		}

	}

/**

Set the subject of this message using a plain descriptor.

The object must have an open message to use this method.

@param aSubject

A descriptor containing the subject for the message.

*/

EXPORT_C void RSendAsMessage::SetSubjectL(const TDesC& aSubject)

	{

	User::LeaveIfError(SendReceive(ESAMSetSubject, TIpcArgs(&aSubject)));

	}

/**

Set the BIO type of this message.

The object must have an open message to use this method.

@param aBioType

The biotype for this message.

*/

EXPORT_C void RSendAsMessage::SetBioTypeL(TUid aBioType)

	{

	TPckgBuf<TUid> pckg(aBioType);

	User::LeaveIfError(SendReceive(ESAMSetBioType, TIpcArgs(&pckg)));

	}

/**

Add a recipient to this message.

The recipient's address is held in a descriptor, and is in the correct format for the

message type.

The recipient type is one of the TSendAsRecipientType constants, currently one of:

ESendAsRecipientTo	-	The recipient goes in the 'To' field.

ESendAsRecipientCc	-	The recipient goes in the 'Cc' field.

ESendAsRecipientBcc	-	The recipient goes in the 'Bcc' field.

If the 'Cc' field is not supported, the recipient will instead be added to the 'To'

field since these are functionally equivalent.

If the 'Bcc' field is not supported, this method will return KErrNotSupported.

@param aAddress

A descriptor holding the address of the recipient to add.

@param aRecipientType

The recipient type of the address being added. See above.

*/

EXPORT_C void RSendAsMessage::AddRecipientL(const TDesC& aAddress, TSendAsRecipientType aRecipientType)

	{

	TPckgBuf<TSendAsRecipientType> pckg(aRecipientType);

	User::LeaveIfError(SendReceive(ESAMAddRecipient, TIpcArgs(&aAddress, &pckg)));

	}

/**

Add a recipient with an alias to this message.

The recipient's address is held in a descriptor, and is in the correct format for the

message type.

The alias is the displayed recipient name.

The recipient type is one of the TSendAsRecipientType constants, currently one of:

ESendAsRecipientTo	-	The recipient goes in the 'To' field.

ESendAsRecipientCc	-	The recipient goes in the 'Cc' field.

ESendAsRecipientBcc	-	The recipient goes in the 'Bcc' field.

If the 'Cc' field is not supported, the recipient will instead be added to the 'To'

field since these are functionally equivalent.

If the 'Bcc' field is not supported, this method will return KErrNotSupported.

@param aAddress

A descriptor holding the address of the recipient to add.

@param aAlias

A descriptor holding the address alias of the recipient to add.

@param aRecipientType

The recipient type of the address being added. See above.

*/

EXPORT_C void RSendAsMessage::AddRecipientL(const TDesC& aAddress, const TDesC& aAlias, TSendAsRecipientType aRecipientType)

	{

	TPckgBuf<TSendAsRecipientType> pckg(aRecipientType);

	User::LeaveIfError(SendReceive(ESAMAddRecipientWithAlias, TIpcArgs(&aAddress, &aAlias, &pckg)));

	}

/**

Add an attachment to this message asynchronously.

A copy of the specified file is attached to message.

@param aAttachmentFile

The file being added to the message as an attachment.

The file is closed if attached successfully. Ownership is transferred .The caller must close the file handle.

@param aMimeType

The mime type for this attachment.

@param aCharset

The charset for this attachment. The value is a standard IANA charset.

@param aStatus

Asynchronous status object (TRequestStatus) that is signalled when the

operation completes. aStatus should be checked by the caller to ensure that the

operation was successful.

*/

EXPORT_C void RSendAsMessage::AddAttachment(RFile& aAttachmentFile, const TDesC8& aMimeType, TUint aCharset, TRequestStatus& aStatus)

	{

	TInt err;

	TIpcArgs args;

	err = aAttachmentFile.TransferToServer(args, 0, 1);

	if (err != KErrNone)

		{

		TRequestStatus* p = &aStatus;

		User::RequestComplete(p, err);

		}

	else

		{

		// Perform synchronous operation to allow server to take ownership of the RFile.

		err = SendReceive(ESAMTransferAttachmentFile, args);

		if  (err != KErrNone)

			{

			TRequestStatus* p = &aStatus;

			User::RequestComplete(p, err);

			}

		else

			{

			// Now it's safe to close the file.

			aAttachmentFile.Close();

			TIpcArgs args2;

			// reuse the args

			args2.Set(0, &aMimeType);	

			args2.Set(1, aCharset); 	

			// Now perform async adding of transfered attachment

			SendReceive(ESAMAddAttachmentWithType, args2, aStatus);

			}

		}

	}

/**

Add an attachment to this message asynchronously.

A copy of the specified file is attached to message.

@param aAttachmentFile

The file being added to the message as an attachment. Ownership is transferred .The caller must close the file handle.

@param aMimeType

The mime type for this attachment.

@param aStatus

Asynchronous status object (TRequestStatus) that is signalled when the

operation completes. aStatus should be checked by the caller to ensure that the

operation was successful.

*/

EXPORT_C void RSendAsMessage::AddAttachment(RFile& aAttachmentFile, const TDesC8& aMimeType, TRequestStatus& aStatus)

	{

	AddAttachment(aAttachmentFile, aMimeType, 0, aStatus);

	}

/**

Add an attachment to this message.

The attachment is copied into the message store from the supplied file.

@param aAttachmentFile

The file being added to the message as an attachment. Ownership is transferred .The caller must close the file handle. 

@param aStatus

Asynchronous status object (TRequestStatus) that is signalled when the

operation completes. aStatus should be checked by the caller to ensure that the

operation was successful.

*/

EXPORT_C void RSendAsMessage::AddAttachment(RFile& aAttachmentFile, TRequestStatus& aStatus)

	{

	TInt err;

	TIpcArgs args;

	err = aAttachmentFile.TransferToServer(args, 0, 1);

	if (err != KErrNone)

		{

		TRequestStatus* p = &aStatus;

		User::RequestComplete(p, err);

		}

	else

		{

		// Perform synchronous operation to allow server to take ownership of the RFile.

		err = SendReceive(ESAMTransferAttachmentFile, args);

		if  (err != KErrNone)

			{

			TRequestStatus* p = &aStatus;

			User::RequestComplete(p, err);

			}

		else

			{

			// Now it's safe to close the file.

			aAttachmentFile.Close();

			// Now perform async adding of transfered attachment

			SendReceive(ESAMAddAttachment, args, aStatus);

			}

		}

	}

/**

Add an attachment to this message asynchronously.

A copy of the specified file is attached to message.

@param aAttachmentFilePath

The file name and path for the file being added to the message as an attachment.

@param aMimeType

The mime type for this attachment.

@param aCharset

The charset for this attachment. The value is a standard IANA charset.

@param aStatus

Asynchronous status object (TRequestStatus) that is signalled when the

operation completes. aStatus should be checked by the caller to ensure that the

operation was successful.

*/	

EXPORT_C void RSendAsMessage::AddAttachment(const TDesC& aAttachmentFilePath, const TDesC8& aMimeType, TUint aCharset, TRequestStatus& aStatus)

	{

	TInt err;

	RFs fs;

	RFile file;

	err = fs.Connect();

	if (err == KErrNone)

		{

		err = fs.ShareProtected();

		if (err == KErrNone)

			{

			err = file.Open(fs, aAttachmentFilePath, EFileRead | EFileShareReadersOnly);

			if (err == KErrNone)

				{

				AddAttachment(file, aMimeType, aCharset, aStatus);

				}

			}

		}

	// On successful adding of an attachment, ownership of the file is

	// transfered. Otherwise clean up must happen here.

	if (err != KErrNone)

		{

		TRequestStatus* p = &aStatus;

		file.Close();

		User::RequestComplete(p, err);

		}

	fs.Close();

	}

/**

Add an attachment to this message asynchronously.

A copy of the specified file is attached to message.

@param aAttachmentFilePath

The file name and path for the file being added to the message as an attachment.

@param aMimeType

The mime type for this attachment.

@param aStatus

Asynchronous status object (TRequestStatus) that is signalled when the

operation completes. aStatus should be checked by the caller to ensure that the

operation was successful.

*/	

EXPORT_C void RSendAsMessage::AddAttachment(const TDesC& aAttachmentFilePath, const TDesC8& aMimeType, TRequestStatus& aStatus)

	{

	AddAttachment(aAttachmentFilePath, aMimeType, 0, aStatus);

	}

/**

Add an attachment to this message.

The attachment is copied into the message store from the supplied filename.

@param aAttachmentFilePath

The file name and path for the file being added to the message as an attachment.

@param aStatus

Asynchronous status object (TRequestStatus) that is signalled when the

operation completes. aStatus should be checked by the caller to ensure that the

operation was successful.

*/

EXPORT_C void RSendAsMessage::AddAttachment(const TDesC& aAttachmentFilePath, TRequestStatus& aStatus)

	{

	TInt err;

	RFs fs;

	RFile file;

	err = fs.Connect();

	if (err == KErrNone)

		{

		err = fs.ShareProtected();

		if (err == KErrNone)

			{

			err = file.Open(fs, aAttachmentFilePath, EFileRead | EFileShareReadersOnly);

			if (err == KErrNone)

				{

				AddAttachment(file, aStatus);

				}

			}

		}

	// On successful adding of an attachment, ownership of the file is

	// transfered. Otherwise clean up must happen here.

	if (err != KErrNone)

		{

		TRequestStatus* p = &aStatus;

		file.Close();

		User::RequestComplete(p, err);

		}

	fs.Close();

	}

/**

Add an attachment to this message.

The attachment is linked to the message from the supplied filename.  This file must be present

when the message is sent.

@param aLinkedAttachmentFile

The file name and path for the file being added to the message as a linked attachment.

@param aMimeType

The mime type for this attachment.

@param aCharset

The charset for this attachment. The value is a standard IANA charset.

@param aStatus

Asynchronous status object (TRequestStatus) that is signalled when the

operation completes. aStatus should be checked by the caller to ensure that the

operation was successful.

*/

EXPORT_C void RSendAsMessage::AddLinkedAttachment(const TDesC& aLinkedAttachmentFile, const TDesC8& aMimeType, TUint aCharset, TRequestStatus& aStatus)

	{

	SendReceive(ESAMAddLinkedAttachmentWithType, TIpcArgs(&aLinkedAttachmentFile, &aMimeType, aCharset), aStatus);

	}

/**

Add an attachment to this message asynchronously.

The attachment is linked to the message from the supplied filename. This file must be present

when the message is sent.

@param aLinkedAttachmentFile

The file name and path for the file being added to the message as a linked attachment.

@param aMimeType

The mime type for this attachment.

@param aStatus

Asynchronous status object (TRequestStatus) that is signalled when the

operation completes. aStatus should be checked by the caller to ensure that the

operation was successful.

*/

EXPORT_C void RSendAsMessage::AddLinkedAttachment(const TDesC& aLinkedAttachmentFile, const TDesC8& aMimeType, TRequestStatus& aStatus)

	{

	AddLinkedAttachment(aLinkedAttachmentFile, aMimeType, 0, aStatus);

	}

/**

Add an attachment to this message asynchronously.

The attachment is linked to the message from the supplied filename. This file must be present

when the message is sent.

@param aLinkedAttachmentFile

The file name and path for the file being added to the message as a linked attachment.

@param aStatus

Asynchronous status object (TRequestStatus) that is signalled when the

operation completes. aStatus should be checked by the caller to ensure that the

operation was successful.

*/

EXPORT_C void RSendAsMessage::AddLinkedAttachment(const TDesC& aLinkedAttachmentFile, TRequestStatus& aStatus)

	{

	SendReceive(ESAMAddLinkedAttachment, TIpcArgs(&aLinkedAttachmentFile), aStatus);

	}

/**

Create an attachment to this message.