/*

* Copyright (c) 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:  Message store session client implementation.

*

*/

// ========

// INCLUDES

// ========

#include <s32mem.h>  // for descriptor read/write streams

#include <f32file.h>

#include "RMessageStoreSession.h"

#include "emailstoreuids.hrh"

#include "MessageStoreClientServer.h"

#include "RMessageStoreSession.h"

//<cmail>

#include "MsgStoreAccount.h"

#include "AccountsSerializer.h"

#include "MsgStoreSortCriteria.h"

#include "MsgStoreSearchCriteria.h"

#include "MsgStoreAddress.h"

//</cmail>

// =========

// CONSTANTS

// =========

const TUint KInitialChildrenIdsTransferBufferLength    = 5000;

const TUint KInitialPropertiesTransferBufferLength     = 10000;

const TUint KInitialPropertiesListTransferBufferLength = 15000;

const TUint KInitialAccountsTransferBufferLength       = 10000;  //shoud be more than enouth

const TUint KInitialSortedListTransferBufferLength     = 30000;

const TUint KInitialSortedIdsAndFlagsBufferLength      = 65536;  //shoud be more than enouth

// This will try to connect to the server for a maximum of 20 seconds.

const TUint KMaxServerConnectRetries         = 20;

const TUint KServerRetryIntervalMicroSeconds = 1000000;

const TUint KNumSlots = 3;

const TUint KIpcArgsIndex2 = 2;

const TUint KIpcArgsIndex3 = 3;

// ======================

// METHOD IMPLEMENTATIONS

// ======================

// ==========================================================================

// FUNCTION: Constructor

// ==========================================================================

RMessageStoreSession::RMessageStoreSession()

    {

    __LOG_CONSTRUCT( "MsgClient", "RMessageStoreSession" )

    } // end constructor

// ==========================================================================

// FUNCTION: Destructor

// ==========================================================================

RMessageStoreSession::~RMessageStoreSession()

    {

    __LOG_DESTRUCT

    } // end destructor

// ==========================================================================

// FUNCTION: Connect

// ==========================================================================

TInt RMessageStoreSession::Connect( TBool /*aLaunchServerIfNeeded*/, TBool aRetryIndefinitely )

    {

    __LOG_ENTER( "Connect" )

    // This flag should only be used in the case where the message store server is being launched as a separate

    // thread within some other process.  In that case, the flag is used to control exactly which process the

    // server will be launched in.  Otherwise, always launch the server on reference.

    //aLaunchServerIfNeeded = ETrue;

    TBool again = ETrue;    

    TInt  returnValue;

    TInt  retry = KMaxServerConnectRetries;

    while( again )

        {

        returnValue = CreateSession( KMsgStoreServerName, TVersion(KMsgStoreMajorVersion, KMsgStoreMinorVersion, KMsgStoreBuild), KNumSlots );

        if( returnValue == KErrNone )

            {

            // No need to retry.

            again = EFalse;            

            }

        else

            {

            __LOG_WRITE8_FORMAT1_ERROR( "CreateSession failed %i", returnValue )

            if( !aRetryIndefinitely )

                {                

                retry--;

                } // end if

            if( retry == 0 )

                {

                // Do not retry again.

                again = EFalse;

                }

            else if( (returnValue == KErrNotFound) || (returnValue == KErrServerTerminated) )

                {

                // Start the server as a thread within the current process.            

                returnValue = StartServer();

                if ( returnValue != KErrNone )

                    {

            				__LOG_WRITE8_FORMAT1_ERROR( "StartServer failed %i", returnValue )

		                // Wait before trying again.

		                User::After( KServerRetryIntervalMicroSeconds );             

		                //stay in the loop even if we failed to start the server,

		                // in the next look, the CreateSession will fail but we get to try StartServer again

                    }

                }

            else

                {

                __LOG_WRITE_ERROR( "waiting between retries" )

                // Wait before trying again.

                User::After( KServerRetryIntervalMicroSeconds );                             

                } // end if

            } // end if

        } // end if

    __LOG_WRITE8_FORMAT1_DEBUG3( "returnValue=%i", returnValue )    

    __LOG_EXIT

    return returnValue;

    } // end Connect

// ==========================================================================

// FUNCTION: StartServer

// ==========================================================================

TInt RMessageStoreSession::StartServer()

    {

    __LOG_ENTER( "StartServer" )

    TInt err = KErrNone;

    // Launch the server executable (i.e. in it its own process).

     __LOG_WRITE_INFO( "Launching server process" )

    // Create a new server process. Simultaneous launching of two such processes 

    // should be detected when the second one attempts to create the server 

    // object, failing with KErrAlreadyExists.

   _LIT( KMsgStoreExeName, "MessageStoreExe" );

    RProcess server;

    err = server.Create( KMsgStoreExeName, KNullDesC ); 

    if( err == KErrNone )

        {

        TRequestStatus stat;

        server.Rendezvous( stat );

        if( stat != KRequestPending )

            {            

            server.Kill( 0 );   // abort startup

            }

        else

            {            

            server.Resume();  // logon OK - start the server thread

            } // end if

        __LOG_WRITE_INFO( "Started" )

        User::WaitForRequest( stat );   // wait for start or death

        __LOG_WRITE8_FORMAT1_INFO( "stat.Int(() = %i", stat.Int() );

        __LOG_WRITE8_FORMAT1_INFO( "ExitReason() = %i", server.ExitReason() );

        TExitCategoryName exitCategory;

        exitCategory = server.ExitCategory();

        __LOG_WRITE_FORMAT1_INFO( "ExitCategory() = %S", &exitCategory );

        // we can't use the 'exit reason' if the server panicked as this

        // is the panic 'reason' and may be '0' which cannot be distinguished

        // from KErrNone  

        err = ( server.ExitType() == EExitPanic ) ? KErrGeneral : stat.Int();

        server.Close();	

        }

    else

        {

        __LOG_WRITE8_FORMAT1_ERROR( "failed to launch server, err=%i", err )

        } // end if

    __LOG_WRITE8_FORMAT1_DEBUG3( "err=%i", err )

    __LOG_EXIT

    return err;

    } // end StartServer

// ==========================================================================

// FUNCTION: Close

// ==========================================================================

void RMessageStoreSession::Close()

    {

    __LOG_ENTER( "Close" )

    RSessionBase::Close();  //basecall

    __LOG_EXIT

    } // end Close

// ==========================================================================

// FUNCTION: EnableEncryptionL

// ==========================================================================

void RMessageStoreSession::EnableEncryptionL()

    {

    __LOG_ENTER( "EnableEncryptionL" )

    User::LeaveIfError( SendReceive( EMsgStoreCmdEnableEncryption ) );

    __LOG_EXIT

    }

// ==========================================================================

// FUNCTION: DisableEncryptionL

// ==========================================================================

void RMessageStoreSession::DisableEncryptionL()

    {

    __LOG_ENTER( "DisableEncryptionL" )

    User::LeaveIfError( SendReceive( EMsgStoreCmdDisableEncryption ) );

    __LOG_EXIT

    }

// ==========================================================================

// FUNCTION: AuthenticatedL

// ==========================================================================

TBool RMessageStoreSession::AuthenticatedL()

    {

    __LOG_ENTER( "AuthenticatedL" )

    TPckgBuf<TBool> resultPckg( EFalse );

	User::LeaveIfError( SendReceive( EMsgStoreCmdAuthenticated, TIpcArgs( &resultPckg ) ) );

    __LOG_WRITE8_FORMAT1_DEBUG3( "result=%i", resultPckg() )

    __LOG_EXIT

    return resultPckg();

    } // end AuthenticatedL

// ==========================================================================

// FUNCTION: AuthenticateL

// ==========================================================================

TBool RMessageStoreSession::AuthenticateL( const TDesC& aPassword )

    {

    __LOG_ENTER( "AuthenticateL" )

    TPckgBuf<TBool> resultPckg( EFalse );

	User::LeaveIfError( SendReceive( EMsgStoreCmdAuthenticate, TIpcArgs( &resultPckg, &aPassword ) ) );

    __LOG_WRITE8_FORMAT1_DEBUG3( "result=%i", resultPckg() )

    __LOG_EXIT

    return resultPckg();

    } // end AuthenticateL

// ==========================================================================

// FUNCTION: ClearAuthenticationL

// ==========================================================================

void RMessageStoreSession::ClearAuthenticationL()

    {

    __LOG_ENTER( "ClearAuthenticationL" )

	User::LeaveIfError( SendReceive( EMsgStoreCmdClearAuthentication ) );

	__LOG_EXIT

    } // end ClearAuthenticationL

// ==========================================================================

// FUNCTION: HasPasswordL

// ==========================================================================

TBool RMessageStoreSession::HasPasswordL()

    {

    __LOG_ENTER( "HasPasswordL" )

    TPckgBuf<TBool> resultPckg( EFalse );

	User::LeaveIfError( SendReceive( EMsgStoreCmdHasPassword, TIpcArgs( &resultPckg ) ) );

    __LOG_WRITE8_FORMAT1_DEBUG3( "result=%i", resultPckg() )   

    __LOG_EXIT

    return resultPckg();

    } // end HasPasswordL

// ==========================================================================

// FUNCTION: SetPasswordL

// ==========================================================================

void RMessageStoreSession::SetPasswordL( const TDesC& aPassword )

    {

    __LOG_ENTER( "SetPasswordL" )

	User::LeaveIfError( SendReceive( EMsgStoreCmdSetPassword, TIpcArgs( &aPassword ) ) );

	__LOG_EXIT

    } // end SetPasswordL

// ==========================================================================

// FUNCTION: ChangePasswordL

// ==========================================================================

TBool RMessageStoreSession::ChangePasswordL( const TDesC& aOldPassword, const TDesC& aNewPassword )

    {

    __LOG_ENTER( "ChangePasswordL" )

    TPckgBuf<TBool> resultPckg( EFalse );

	User::LeaveIfError( SendReceive( EMsgStoreCmdChangePassword, TIpcArgs( &resultPckg, &aOldPassword, &aNewPassword ) ) );

    __LOG_WRITE8_FORMAT1_DEBUG3( "result=%i", resultPckg() )  

    __LOG_EXIT

	return resultPckg();

    } // end ChangePasswordL

//account management

// ==========================================================================

// FUNCTION: CreateAccountL

// ==========================================================================

TMsgStoreId RMessageStoreSession::CreateAccountL( const CMsgStoreAccount& aAccount, const TDesC8& aProperties )

	{

    __LOG_ENTER( "CreateAccountL" )

    TPckgBuf<TMsgStoreId> resultPckg( KMsgStoreInvalidId );

    TInt32 ownerId = aAccount.Owner();

    const TDesC& name = aAccount.Name();

	User::LeaveIfError( SendReceive( EMsgStoreCmdCreateAccount, TIpcArgs( &resultPckg, ownerId, &name, &aProperties ) ) );

    __LOG_WRITE8_FORMAT1_DEBUG3( "result=%u", resultPckg() )  

    __LOG_EXIT

	return resultPckg();

	}

// ==========================================================================

// FUNCTION: OpenAccountL

// ==========================================================================

TMsgStoreId RMessageStoreSession::OpenAccountL( const CMsgStoreAccount& aAccount, RBuf8& aBuffer )

	{

    __LOG_ENTER( "OpenAccountL" )

    TUint result = 1;

    TPckg<TUint> resultPckg( result );

	TMsgStoreOpenAccountCmdParams params;

	TPckg<TMsgStoreOpenAccountCmdParams> paramsPckg( params );

	params.iOwnerId = aAccount.Owner();

    const TDesC& name = aAccount.Name();

	aBuffer.CreateL( KInitialPropertiesTransferBufferLength );

    while( result != 0 )

	    {	   

	    User::LeaveIfError( SendReceive( EMsgStoreCmdOpenAccount, TIpcArgs( &resultPckg, &paramsPckg, &name, &aBuffer ) ) );

	    // The buffer was too small.  Reallocate.

	    if( result != 0 )

	        {

	        __LOG_WRITE8_FORMAT1_INFO( "growing buffer to %i", result );

	        aBuffer.ReAllocL( result );

	        }

	    } // end while

    __LOG_WRITE8_FORMAT1_DEBUG3( "result=%u", resultPckg() )    

    __LOG_EXIT

	return params.iMailBoxId;

	}

// ==========================================================================

// FUNCTION: DeleteAccountL

// ==========================================================================

void RMessageStoreSession::DeleteAccountL( const CMsgStoreAccount& aAccount )

	{

    __LOG_ENTER( "DeleteAccountL" )

    TInt32 ownerId = aAccount.Owner();

    const TDesC& name = aAccount.Name();

	User::LeaveIfError( SendReceive( EMsgStoreCmdDeleteAccount, TIpcArgs( ownerId, &name ) ) );

	__LOG_EXIT

	}

// ==========================================================================

// FUNCTION: RenameAccountL

// ==========================================================================

void RMessageStoreSession::RenameAccountL( TInt32 aOwnerId, const TDesC& aOldName, const TDesC& aNewName )

	{

    __LOG_ENTER( "RenameAccountL" )

	User::LeaveIfError( SendReceive( EMsgStoreCmdRenameAccount, TIpcArgs( aOwnerId, &aOldName, &aNewName ) ) );

	__LOG_EXIT

	}

// ==========================================================================

// FUNCTION: AccountsL

// ==========================================================================

void RMessageStoreSession::AccountsL( RPointerArray<CMsgStoreAccount>& aAccounts )

	{

    __LOG_ENTER( "AccountsL" )

    RBuf8 resultBuf;

    CleanupClosePushL( resultBuf );

    resultBuf.CreateL( KInitialAccountsTransferBufferLength );

	User::LeaveIfError( SendReceive( EMsgStoreCmdListAccounts, TIpcArgs( &resultBuf ) ) );

	CAccountsSerializer* serializer = new(ELeave)CAccountsSerializer();

	CleanupStack::PushL( serializer );

	serializer->DeserializeL( resultBuf );

	TInt count = serializer->Count();

	RArray<TInt32>& ownerIds = serializer->OwnerIds();

    RPointerArray<HBufC>& names = serializer->NamesArray();

	for ( int i = 0 ; i < count ; i++ )

		{

		CMsgStoreAccount* account = CMsgStoreAccount::NewL( ownerIds[i], *(names[i]) );

		aAccounts.AppendL( account );

		}

	CleanupStack::PopAndDestroy( serializer );

	CleanupStack::PopAndDestroy( &resultBuf );

	__LOG_EXIT

	}

// ==========================================================================

// FUNCTION: StartObservingL

// ==========================================================================

void RMessageStoreSession::StartObservingL()

	{

	__LOG_ENTER( "StartObservingL" )

	User::LeaveIfError( SendReceive( EMsgStoreCmdStartObserving ) );

	__LOG_EXIT

	} // end StartObservingL

// ==========================================================================

// FUNCTION: GetEvents

// ==========================================================================

void RMessageStoreSession::GetEvents( TRequestStatus& aStatus, TDes8& aBuffer )

	{

	__LOG_ENTER( "GetEvents" )

	aBuffer.SetLength( 0 );

    SendReceive( EMsgStoreCmdGetEvents, TIpcArgs( &aBuffer ), aStatus );

    __LOG_EXIT

	} // end GetEvents

// ==========================================================================

// FUNCTION: StopObserving

// ==========================================================================

void RMessageStoreSession::StopObserving()

	{

	__LOG_ENTER( "StopObserving" )

	SendReceive( EMsgStoreCmdStopObserving );

	__LOG_EXIT

	} // end StopObserving

// ==========================================================================

// FUNCTION: CreateContainerL

// ==========================================================================

TMsgStoreId RMessageStoreSession::CreateContainerL( TMsgStoreId             aParentId,

													TMsgStoreId             aGrandparentId,

													TMsgStoreId             aMailBoxId,

													TMsgStoreContainerMasks aType,

								                    const TDesC8&           aProperties,

								                    TBool                   aCommitContainer,

								                    const TDesC&            aContentFilename )

	{

	__LOG_ENTER( "CreateContainerL" )

	TMsgStoreCreateContainerCmdParams params;

	TPckg<TMsgStoreCreateContainerCmdParams> paramsPckg( params );

	params.iParentId        = aParentId;

	params.iGrandparentId   = aGrandparentId;

	params.iMailBoxId       = aMailBoxId;

	params.iCommitContainer = aCommitContainer;

	params.iType            = aType;

	params.iHasContent      = ( aContentFilename.Length() > 0 );

	TIpcArgs ipcArgs( &paramsPckg, &aProperties );

    // Platform security documentation recommends using different file system session for

    // each file handle that is transferred between processes.