/*

* Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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 <e32base.h>

#include <SendUiConsts.h>

#include <mmsconst.h>

#include <cmsvattachment.h>

#include <aknenv.h>

#include <mtclreg.h>

#include <utf.h>

#include <mturutils.h>      

#include <aknenv.h>

#include <apgcli.h>

#include <smsclnt.h>

#include <txtrich.h>

#include <smuthdr.h>

#include <smscmds.h>

#include <mtmuibas.h>

#include <mtuireg.h>

#include <s32mem.h>

#include "messageheader.h"

#include "sendmessage.h"

_LIT(KBodyTextFilePath,"C:\\");

// ---------------------------------------------------------------------------

// Two-phased constructor.

// ---------------------------------------------------------------------------

//

CSendMessage* CSendMessage::NewL( CMsvSession& aServerSession )

	{

	CSendMessage* self = new (ELeave) CSendMessage( aServerSession );

	return self;

	}

// ---------------------------------------------------------------------------

// Destructor.

// ---------------------------------------------------------------------------

//

CSendMessage::~CSendMessage()

	{

	if ( IsActive() )

		{

		iCallNotifyForCancelFlag = EFalse;

		Cancel();

		}

	iMessage.Close();

	iSendAs.Close();

	delete iMessageParam;

	delete iNotifyCallback;

	delete iTemplateDetail;

	}

// ---------------------------------------------------------------------------

// Two-phased constructor.

// ---------------------------------------------------------------------------

//

CSendMessage::CSendMessage( CMsvSession& aServerSession ):

				CActive( EPriorityStandard ),

				iServerSession( aServerSession ),

				iCallNotifyForCancelFlag(ETrue),

				iBodyTextFileFlag(EFalse)

	{

	}

// ---------------------------------------------------------------------------

// Sets message input parameters 

// aMessageParam/aTemplateDetail/aNotifyCallback ownership is passed to this

// ---------------------------------------------------------------------------

//

void CSendMessage::SetInputParamsL( CSendMessageParams* aMessageParam,

									CMessageDetailInfo* aTemplateDetail,

									CMsgCallbackBase* aNotifyCallback,

									MAsyncRequestObserver* aAsyncRequestObserver )

	{

	iMessageParam = CSendMessageParams::NewL();

	*iMessageParam = *aMessageParam;

	iNotifyCallback = aNotifyCallback;

	iTemplateDetail = aTemplateDetail;

	iAsyncRequestObserver = aAsyncRequestObserver;

	}

// ---------------------------------------------------------------------------

// Sends the message

// ---------------------------------------------------------------------------

//

void CSendMessage::SendMessageL()

	{

	if ( iNotifyCallback ) // making call as asynchronous

		{

		CActiveScheduler::Add( this );

		if ( iMessageParam->MessageType() == KSenduiMtmSmsUid )

		    {

		    iMessageState = ESend;

		    }

		else

		    {

		    iMessageState = EInitialize;

		    }

		ActivateRequest( KErrNone );

		}

	else				// making call as synchronous

		{

		if ( iMessageParam->MessageType() == KSenduiMtmMmsUid )

		    {

            InitializeL();

            ValidateL();

		    }

		SendL();

		}

	}

// ---------------------------------------------------------------------------

// Inherited from CActive class 

// ---------------------------------------------------------------------------

//

void CSendMessage::DoCancel()

	{

	NotifyRequestResult( KErrCancel );

	}

// ---------------------------------------------------------------------------

// Inherited from CActive class 

// ---------------------------------------------------------------------------

//

void CSendMessage::RunL()

	{

	TInt err = iStatus.Int();

	if ( err == KErrNone )

		{

		switch ( iMessageState )

			{

			case EInitialize: 

				{

				TRAP( err, InitializeL() );

				iMessageState = EValidate;

				ActivateRequest( err );

				}

				break;	

			case EValidate: 

				{

				TRAP( err, ValidateL() );

				iMessageState = ESend;

				ActivateRequest( err );

				}

				break;	

			case ESend: 

				{

				TRAP( err, SendL() );

				iMessageState = EComplete;

				ActivateRequest( err );

				}

				break;

			case EComplete: 

				{

				NotifyRequestResult( err );

				}

				break;

			default:

				NotifyRequestResult( KErrGeneral );	

				break;	

			}

		}

	else

		{

		NotifyRequestResult( err );		

		}

	}

// ---------------------------------------------------------------------------

// Initialises RSendAs Server object and RSendAsMessage Object

// ---------------------------------------------------------------------------

//

void CSendMessage::InitializeL()

	{

	TInt err;

	err = iSendAs.Connect();

	if ( err == KErrNone )

        {

        iMessage.CreateL( iSendAs, iMessageParam->MessageType() );

        }

    else

        {

        User::Leave(err);   

        }

	if ( iTemplateDetail )

		{

		if ( iTemplateDetail->BodyText().Length() )

			{

			iMessageParam->AppendBodyTextL( iTemplateDetail->BodyText() );

			}

		const CArrayPtr<CMessageAttachInfo>* attacharray = iTemplateDetail->AttachmentInfoArray();

		if ( attacharray )

			{

			for ( TInt pos = 0; pos < attacharray->Count(); pos++ )

				{

				CMessageAttachInfo* element = (*attacharray)[pos];

				TBuf8<KMaxFileName> tmpMime;

				tmpMime.Copy( element->MimeType() );

				TRequestStatus stat;

				RFile fileHandle = element->FileHandle();

				if(tmpMime.CompareF(KMmsTextPlain))

				   {

				   iMessage.AddAttachment( fileHandle, tmpMime, 0, stat );

				   }

				else

				   {

				   iMessage.AddAttachment( fileHandle, tmpMime, stat );				

				   }

				User::WaitForRequest( stat );

				}

			}

		delete iTemplateDetail;

		iTemplateDetail = NULL;

		}

	}

// ---------------------------------------------------------------------------

// Sets Subject, Recipient, BodyText, Attachments to RSendAsMessage object

// ---------------------------------------------------------------------------

//

void CSendMessage::ValidateL()

	{

	AddSubjectL();

	AddRecipientL();

	AddBodyTextL();

	AddAttachmentL();

	}

// ---------------------------------------------------------------------------

// Internal function 

// ---------------------------------------------------------------------------

//

void CSendMessage::SendL()

	{

	if ( iMessageParam->MessageType() == KSenduiMtmSmsUid )

	    {

 	    SendSMSMessageL();

	    }

	else if ( iMessageParam->MessageType() == KSenduiMtmMmsUid )

	    {

        if( iMessageParam->LaunchEditor() )

            {

            iMessage.LaunchEditorAndCloseL();

            }

        else

            {

            iMessage.SendMessageAndCloseL();

            }

	    }

	if( iBodyTextFileFlag )	//If the bodytext attach file is created for mms, delete it

		{

		RFs rFs;

    	if( rFs.Connect() == KErrNone )

    		{

    		rFs.Delete( iBodyTextFileName ); //if found delete it b4 creating it

   			rFs.Close();	

    		}

		}

	}

// ---------------------------------------------------------------------------

// Activates the asynchronous request

// ---------------------------------------------------------------------------

//

void CSendMessage::ActivateRequest( TInt aReason )

	{

	iStatus = KRequestPending;

	SetActive();

	TRequestStatus* temp = &iStatus;

	User::RequestComplete( temp, aReason );

	}

// ---------------------------------------------------------------------------

// Notifies callback the result for asynchronous request.

// ---------------------------------------------------------------------------

//

void CSendMessage::NotifyRequestResult( TInt aReason )

	{

	if ( iNotifyCallback )

		{

		iAsyncRequestObserver->RequestComplete( iNotifyCallback->iTransactionId );

		if( iCallNotifyForCancelFlag )

			{

			TRAPD( err, iNotifyCallback->NotifyResultL( aReason, NULL ));	

			}

		}

	// caller will delete the object in case of cancel

	if ( aReason != KErrCancel )

		delete this;

	}

// ---------------------------------------------------------------------------

// Sets the subject for message

// ---------------------------------------------------------------------------

//

void CSendMessage::AddSubjectL()

	{

	TPtrC subject( iMessageParam->Subject());

	if ( subject.Length() )

		iMessage.SetSubjectL( iMessageParam->Subject() );

	}

// ---------------------------------------------------------------------------

// Sets the recipient address.

// ---------------------------------------------------------------------------

//

void CSendMessage::AddRecipientL()

	{

	const CRecipientList* recipientArray = iMessageParam->RecipientArray();

	if ( recipientArray )

		{

		TInt count = recipientArray->Count();

		for( TInt pos = 0; pos < count; pos++ )

			{

			iMessage.AddRecipientL( (*recipientArray)[pos], 

				RSendAsMessage::TSendAsRecipientType( recipientArray->Type(pos) ) );

			}

		}

	else if ( !iMessageParam->LaunchEditor() )

		{

		User::Leave( KErrArgument );

		}

	}

// ---------------------------------------------------------------------------

// Sets body text to message.

// ---------------------------------------------------------------------------

//

void CSendMessage::AddBodyTextL()

	{

	TPtrC filePath( KBodyTextFilePath );

	TPtrC bodyText = iMessageParam->BodyText();

	if ( bodyText.Length() )

		{

		if ( iMessageParam->MessageType() == KSenduiMtmMmsUid )

			{

    		RFs rFs;

			RFile tmpfile;

    		User::LeaveIfError( rFs.Connect() );

    		tmpfile.Temp(rFs, filePath, iBodyTextFileName, EFileShareExclusive|EFileWrite);

			iBodyTextFileFlag = ETrue;

			HBufC8* buffer=HBufC8::NewL( bodyText.Length()* 4  );

			TPtr8 tmpBuffer = buffer->Des();

			CnvUtfConverter::ConvertFromUnicodeToUtf8(tmpBuffer, bodyText);

			CleanupStack::PushL( buffer );

			buffer->Des().Copy( tmpBuffer );

			tmpfile.Write( *buffer ); 

			tmpfile.Flush();

			tmpfile.Close();			

			rFs.Close();

			CleanupStack::PopAndDestroy( buffer );

			TRequestStatus stat;

			iMessage.AddAttachment( iBodyTextFileName, KMmsTextPlain, 0, stat );

			User::WaitForRequest( stat );

			}

		else

			{

			iMessage.SetBodyTextL( bodyText );	

			}

		}

	}

// ---------------------------------------------------------------------------

// Adds attachments to message

// ---------------------------------------------------------------------------

//

void CSendMessage::AddAttachmentL()

	{

	const CArrayPtr<CMsvAttachment>* attachmentArray = iMessageParam->AttachmentArray();

	if ( attachmentArray && attachmentArray->Count() > 0 )

		{

		TRequestStatus attachstatus;

		TInt error = KErrNone;

		TInt count;

		RApaLsSession rapaSesion;

		RFs rFs;

		RFile tmpfile;

		User::LeaveIfError( rapaSesion.Connect() );

		CleanupClosePushL( rapaSesion );

		User::LeaveIfError( rFs.Connect() );

		CleanupClosePushL( rFs );

		for ( count = 0; count < attachmentArray->Count(); count++ )

			{

			attachstatus = KRequestPending;	

			error = tmpfile.Open(rFs, ((*attachmentArray)[count])->AttachmentName(), EFileRead);

			if( error == KErrNone )

				{

				TBuf8<256> tmpbuf;

				tmpfile.Read(tmpbuf, 255 );

				tmpfile.Close();

				TDataRecognitionResult aDataType;

				error = rapaSesion.RecognizeData(((*attachmentArray)[count])->AttachmentName(), tmpbuf, aDataType);

				if( error == KErrNone )

					{

					TBuf8< KMaxDataTypeLength > tmp;

					tmp.Copy( aDataType.iDataType.Des() );

					if(!(tmp.CompareF(KMmsTextPlain)))

                        {

                        iMessage.AddAttachment( ((*attachmentArray)[count])->AttachmentName(),

                                                                        tmp, 0,

                                                                        attachstatus ); 

                        }

					else

					    {

					    iMessage.AddAttachment( ((*attachmentArray)[count])->AttachmentName(),

												tmp,

												attachstatus );								

					    }

					}

				else

					{					

					if ( ((*attachmentArray)[count])->MimeType().Length() )

						{

						iMessage.AddAttachment( ((*attachmentArray)[count])->AttachmentName(),

												((*attachmentArray)[count])->MimeType(),

												attachstatus );

						}

					else

						{

						iMessage.AddAttachment( ((*attachmentArray)[count])->AttachmentName(), 

												attachstatus );

						}

					}	

				User::WaitForRequest( attachstatus );

				User::LeaveIfError( attachstatus.Int() );	

				}

			else

				{

				User::Leave( error );				

				}	

			}

		CleanupStack::PopAndDestroy( &rFs );	

		CleanupStack::PopAndDestroy( &rapaSesion );

		}

	}

// ---------------------------------------------------------------------------

// Two-phased constructor.

// ---------------------------------------------------------------------------

//

CAsyncWaiter* CAsyncWaiter::NewL(TInt aPriority)

    {

    CAsyncWaiter* self = new(ELeave) CAsyncWaiter(aPriority);

    return self;

    }

// ---------------------------------------------------------------------------

// Two-phased constructor.