/*

* 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 "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:  Implementation of the class CFsMtmClient.

*

*/

// INCLUDE FILES

#include "emailtrace.h"

#include <txtrich.h>

#include <msvids.h>

#ifndef FF_CMAIL_INTEGRATION

#include <mtmuidsdef.hrh>

#endif // FF_CMAIL_INTEGRATION

#include <mtmdef.h>

#include <msvuids.h>

#include <bautils.h>

#include <featmgr.h>

#include <centralrepository.h>

#include "freestyleemailcenrepkeys.h"

#include <MeetingRequestIds.hrh>

#include "cfssendashelper.h"

#include "fsmtmsconstants.h"

#include "cfsclientmtm.h"

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

// CFsMtmClient::NewL

// Factory function. This will be called by messaging frame work while

// creating client side MTM. The ordinal of this function is assigned to

// entry_point in fsmtms.rss file. The ordinal can be found in

// FsClientMtmU.DEF

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

//

EXPORT_C CFsMtmClient* CFsMtmClient::NewL(

    CRegisteredMtmDll& aRegisteredMtmDll, CMsvSession& aMsvSession)

    {

    FUNC_LOG;

    CFsMtmClient* self = new (ELeave) CFsMtmClient( aRegisteredMtmDll,

        aMsvSession );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self ); //SCANNER

    return self;

    }

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

// CFsMtmClient::CFsMtmClient

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

//

CFsMtmClient::CFsMtmClient( CRegisteredMtmDll& aRegisteredMtmDll,

    CMsvSession& aMsvSession ):CBaseMtm( aRegisteredMtmDll, aMsvSession )

    {

    FUNC_LOG;

    }

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

// CFsMtmClient::ConstructL

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

//

void CFsMtmClient::ConstructL()

    {

    FUNC_LOG;

    SwitchCurrentEntryL( KMsvRootIndexEntryId );

    iSendAsHelper = CFsSendAsHelper::NewL();

    // Check configuration status of "email attached in email" from cenrep

    // and set flag according to that.

    CRepository* repository = NULL;

    TRAPD( ret, repository = CRepository::NewL( KFreestyleEmailCenRep ) );

    if ( ret == KErrNone )

    	{

        CleanupStack::PushL( repository );

    	TInt rval = KErrNone;

    	TInt hidefeature = 0;

        rval = repository->Get( KEmailHideFS205UIFeature, hidefeature );

        if( rval == KErrNone && hidefeature == EFalse )

        	{

        	iEmailAttachedInEmail = ETrue;

        	iActiveSchedulerWait = CMsvOperationActiveSchedulerWait::NewLC();

			CleanupStack::Pop(); // iActiveSchedulerWait

        	}

        CleanupStack::PopAndDestroy( repository );

    	}

    }

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

// CFsMtmClient::~CFsMtmClient

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

//

CFsMtmClient::~CFsMtmClient()

    {

    FUNC_LOG;

    delete iAccountEntry;

    delete iSendAsHelper;

    if ( iEmailAttachedInEmail )

    	{

	    delete iActiveSchedulerWait;

    	}

    }

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

// CFsMtmClient::AddAddresseeL

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

//

void CFsMtmClient::AddAddresseeL( const TDesC& aRealAddress )

    {

    FUNC_LOG;

    TRAPD( err, iSendAsHelper->AddRecipientL( aRealAddress, KNullDesC,

        EMsvRecipientTo ) );

    if( err != KErrNone )

        {

        }

    }

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

// CFsMtmClient::AddAddresseeL

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

//

void CFsMtmClient::AddAddresseeL( const TDesC& aRealAddress,

    const TDesC& aAlias )

    {

    FUNC_LOG;

    TRAPD( err, iSendAsHelper->AddRecipientL( aRealAddress, aAlias,

        EMsvRecipientTo ) );

    if( err != KErrNone )

        {

        }

    }

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

// CFsMtmClient::AddAddresseeL

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

//

void CFsMtmClient::AddAddresseeL( TMsvRecipientType aType,

    const TDesC& aRealAddress )

    {

    FUNC_LOG;

    TRAPD( err, iSendAsHelper->AddRecipientL( aRealAddress, KNullDesC, aType ) );

    if( err != KErrNone )

        {

        }

    }

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

// CFsMtmClient::AddAddresseeL

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

//

void CFsMtmClient::AddAddresseeL( TMsvRecipientType aType,

    const TDesC& aRealAddress, const TDesC& aAlias )

    {

    FUNC_LOG;

    TRAPD( err, iSendAsHelper->AddRecipientL( aRealAddress, aAlias, aType ) );

    if( err != KErrNone )

        {

        }

    }

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

// CFsMtmClient::RemoveAddressee

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

//

void CFsMtmClient::RemoveAddressee(TInt /*aIndex*/)

    {

    FUNC_LOG;

    }

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

// CFsMtmClient::CFsMtmClient

// Store entry data. If it is a service entry, store the current settings.

// Otherwise it has to be a message.

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

//

void CFsMtmClient::SaveMessageL()

    {

    FUNC_LOG;

    HBufC* buf = HBufC::NewL( Body().DocumentLength() );

    CleanupStack::PushL( buf );

    TPtr ptr = buf->Des(); 

    Body().Extract( ptr, 0 );

    // INFO : By default the body will have x2029, so checking for > 1

    if ( ptr.Length() > 0 )

        {

        iSendAsHelper->SetBodyL( ptr );

        }

    CleanupStack::PopAndDestroy(buf);    

    // Save the message

    iAccountId = iMsvEntry->Entry().iServiceId;

    delete iAccountEntry;

    iAccountEntry = NULL;

    iAccountEntry = CMsvEntry::NewL( Session(), iAccountId,

        TMsvSelectionOrdering( KMsvNoGrouping, EMsvSortByNone,

        ETrue ));

    TUint pluginId = iAccountEntry->Entry().MtmData1();

    TUint id = iAccountEntry->Entry().MtmData2();

    iSendAsHelper->StoreDataL(pluginId, id);

    }

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

// CFsMtmClient::LoadMessageL

// Restore entry data Operation inverse to StoreL

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

//

void CFsMtmClient::LoadMessageL()

    {

    FUNC_LOG;

    }

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

// CFsMtmClient::ReplyL

// Not supported

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

//

CMsvOperation* CFsMtmClient::ReplyL (TMsvId /*aReplyEntryId*/,

    TMsvPartList /*aPartlist*/, TRequestStatus& /*aCompletionStatus*/ )

    {

    FUNC_LOG;

    User::Leave( KErrNotSupported );

    return NULL; //To statisfy the compiler

    }

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

// CFsMtmClient::ReplyL

// Not supported

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

//

CMsvOperation* CFsMtmClient::ForwardL( TMsvId /*aReplyEntryId*/,

    TMsvPartList /*aPartlist*/, TRequestStatus& /*aCompletionStatus*/ )

    {

    FUNC_LOG;

    User::Leave( KErrNotSupported );

    return NULL;

    }

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

// CFsMtmClient::ValidateMessage

// Not supported

// Message validation

// The only thing about the message that can be invalid

// is the iDescription, which should be an acceptable file name. So, length isn't

// allowed to be zero, and backslashes are not allowed in iDescription.

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

//

TMsvPartList CFsMtmClient::ValidateMessage( TUint /*aPartlist*/ )

    {

    FUNC_LOG;

    return 0; //SCANNER

    }

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

// CFsMtmClient::Find

// Not supported

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

//

TMsvPartList CFsMtmClient::Find( const TDesC& /*aTextToFind*/,

    TMsvPartList /*aPartlist*/ )

    {

    FUNC_LOG;

    return 0;

    }

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

// CFsMtmClient::QueryCapability

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

//

TInt CFsMtmClient::QueryCapability( TUid aCapability, TInt& aResponse )

    {

    FUNC_LOG;

    TInt error = KErrNone;

    switch ( aCapability.iUid )

        {

        case KUidMtmQueryMaxBodySizeValue:

        case KUidMtmQueryMaxTotalMsgSizeValue:

            aResponse = KMaxTInt;

            break;

        case KUidMtmQuerySupportedBodyValue:

            aResponse = KMtm7BitBody + KMtm8BitBody + KMtm16BitBody +

                KMtmBinaryBody;

            break;

        case KUidMtmQuerySupportAttachmentsValue:

        case KUidMtmQueryCanSendMsgValue:

            aResponse = ETrue;

            break;

        // Required to make MTM support the MR

        case KMtmUiSupportMeetingRequest:

            aResponse = ETrue;

            break;

        default:

            error = KErrNotSupported;

        }

    return error;

    }

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

// CFsMtmClient::SetSubjectL

// Sets the message context's subject text

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

//

void CFsMtmClient::SetSubjectL(const TDesC& aSubject)

    {

    FUNC_LOG;

    TRAPD( err, iSendAsHelper->SetSubjectL( aSubject) );

    if ( err != KErrNone )

        {

        }

}

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

// CFsMtmClient::AddAttachmentL

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

//

void  CFsMtmClient::AddAttachmentL(const TDesC& aFilePath,

    const TDesC8& aMimeType, TUint aCharset, TRequestStatus& aStatus)

    {

    FUNC_LOG;

    TRAPD( err,

    {

        iSendAsHelper->AddAttachmentL(aFilePath, aMimeType, aCharset );

    });

    if ( err != KErrNone )

        {

        }

    //Complete ourselves immediately.

    TRequestStatus* status = &aStatus;

    User::RequestComplete( status, KErrNone );

    }

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

// CFsMtmClient::AddAttachmentL

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

//

void CFsMtmClient::AddAttachmentL(RFile& aFile, const TDesC8& aMimeType,

    TUint aCharset, TRequestStatus& aStatus)

    {

    FUNC_LOG;

    iSendAsHelper->AddAttachmentL(aFile, aMimeType, aCharset );

    //Complete ourselves immediately.

    TRequestStatus* status = &aStatus;

    User::RequestComplete( status, KErrNone );

    }

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

// CFsMtmClient::AddLinkedAttachmentL

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

//

void CFsMtmClient::AddLinkedAttachmentL(const TDesC& aFilePath,

    const TDesC8& aMimeType, TUint aCharset, TRequestStatus& aStatus )

    {

    FUNC_LOG;

    iSendAsHelper->AddAttachmentL(aFilePath, aMimeType, aCharset );

    //Complete ourselves immediately.

    TRequestStatus* status = &aStatus;

    User::RequestComplete( status, KErrNone );

    }

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

// CFsMtmClient::AddEntryAsAttachmentL

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

//

void CFsMtmClient::AddEntryAsAttachmentL(TMsvId /*aAttachmentId*/,

    TRequestStatus& /*aStatus*/)

    {

    FUNC_LOG;

    User::Leave( KErrNotSupported );

    }

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

// CFsMtmClient::CreateAttachmentL

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

//

void CFsMtmClient::CreateAttachmentL( const TDesC& /*aFileName*/,

        RFile& /*aAttachmentFile*/, const TDesC8& /*aMimeType*/,

        TUint /*aCharset*/, TRequestStatus& /*aStatus*/)

    {

    FUNC_LOG;

    }

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

// CFsMtmClient::InvokeSyncFunctionL

// Call MTM-specific operation synchronously

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

//

void CFsMtmClient::InvokeSyncFunctionL( TInt aFunctionId,

    const CMsvEntrySelection& aSelection, TDes8& aParameter )

    {

    FUNC_LOG;

    if ( aFunctionId == KMTMMailAddressRequestFunctionId &&

        ( &aSelection )->Count() > 0 ) //SCANNER

        {

        CMsvEntry* root = CMsvEntry::NewL( Session(), KMsvRootIndexEntryId,

            TMsvSelectionOrdering( KMsvNoGrouping, EMsvSortByNone, ETrue ) );

        CleanupStack::PushL( root );

        root->SetEntryL( ( &aSelection )->At( 0 ) );

        // aParameter =

        aParameter.Copy( root->Entry().iDescription );

        CleanupStack::PopAndDestroy( root );

        }

    else if ( iEmailAttachedInEmail &&

    		( aFunctionId == KEasEmailMTMAddEmailAttachment ||

    		  aFunctionId == KEasEmailMTMDeleteEntry ) )

        {

   		TInt error = KErrNone;

		CMsvOperation* operation = InvokeAsyncFunctionL( aFunctionId, aSelection, aParameter, iActiveSchedulerWait->iStatus );

		if ( operation )

    		{

			iActiveSchedulerWait->Start();

			// for now, the iStatus.Int contains the new entry ID in mtm

			iMTMAttachmentId = iActiveSchedulerWait->iStatus.Int();

			if ( iMTMAttachmentId <= 0 )

                {

                error = iActiveSchedulerWait->iStatus.Int();

                }

			else

                {

                error = KErrNone;

                }

			delete operation;

		    }

		else

		    {

			error = KErrNotSupported;

		    }

		User::LeaveIfError( error );

    	}

    else

        {

        User::Leave( KErrNotSupported );

        }

    }

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

// CFsMtmClient::InvokeAsyncFunctionL

// Call MTM-specific operation asynchronously

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

//

CMsvOperation* CFsMtmClient::InvokeAsyncFunctionL(

    TInt aFunctionId,

    const CMsvEntrySelection &aSelection,

    TDes8 &aParameter,

    TRequestStatus &aCompletionStatus)

    {

    FUNC_LOG;

	if ( iEmailAttachedInEmail )

		{

	    CMsvOperation* operation = 0;

	    if ( aFunctionId == KMTMStandardFunctionsSendMessage )

		    {

		    operation = CMsvCompletedOperation::NewL( Session(), Type(), KNullDesC8, iAccountId, aCompletionStatus );

	        }

	    else if ( ( aFunctionId >= 0 ) && ( aFunctionId < KEasEmailMTMLastCommand ) )

	        {

			operation = Session().TransferCommandL( aSelection, aFunctionId, aParameter, aCompletionStatus );

			}

		return operation;

		}

	else

		{

	    User::Leave( KErrNotSupported );

		}

	return NULL;

    }

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

// CFsMtmClient::ContextEntrySwitched

// Called by the base class functions SwitchCurrentEntryL() and

// SetCurrentEntryL() when the context is changed to another entry.

// Implementation should clear iAddresseeList & any MTM specific cache.

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

//

void CFsMtmClient::ContextEntrySwitched()

    {

    FUNC_LOG;

    }