/*

* Copyright (c) 2002-2005 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: 

* class for imps access client.

*

*/

// INCLUDE FILES

#include    <e32base.h>

#include    "impsservercommon.h"

#include    "impsaccesshandler.h"

#include    "impsaccesscommand.h"

#include    "impsaccesscli.h"

#include    "impserrors.h"

#include    "impsclient.h"

#include    "impsutils.h"

// ================= MEMBER FUNCTIONS =======================

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

// RImpsAccessClient2::RImpsAccessClient2

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

//

EXPORT_C RImpsAccessClient2::RImpsAccessClient2() :

        RImpsClient2(),

        iCommand( NULL ),

        iHandlerCallBack( NULL ),

        iLoginOpId( 0 ),

        iLoginCancelled( EFalse )

    {

    SetOpIdRange( ); 

    }

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

// RImpsAccessClient2::RegisterL

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

//

EXPORT_C void RImpsAccessClient2::RegisterL(

    RImpsEng& aEngine,

    MImpsAccessHandler2* aObserver,

    TInt aPriority )

    {

    iHandlerCallBack = aObserver;

    iHandler = CImpsAccessHandler2::NewL( *this, aPriority );

    iCommand = CImpsAccessCommand2::NewL( *this );

    iActiveCommand = iCommand;

    // Start the handler

    iHandler->StartRun();

    iHandleNew = ETrue;

    iAnyContent = EFalse;

    TInt err = DoRegister( aEngine, iHandler );

    User::LeaveIfError( err );

    }

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

// RImpsAccessClient2::Unregister()

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

EXPORT_C void RImpsAccessClient2::Unregister()

    {

    DoUnregister();

    }

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

// RImpsAccessClient2::LoginL()

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

EXPORT_C TInt RImpsAccessClient2::LoginL( TImpsCspIdentifier aCspId,

                              const TDesC& aPsw,

                              const TDesC& aClientId,

                              TUint32 aAP,

                              const TDesC* aKey1,

                              const TDesC* aKey2  )

    {

    if ( !iRunning ) 

        {

        User::Leave( KImpsErrorNotRegistered);

        }

    // Check length of parameters

    if ( ( aCspId.Sap().Length() > KImpsMaxSAP ) ||

         ( aPsw.Length() > KImpsMaxPwd ) ||

         ( aClientId.Length() > KImpsMaxClientId ) )

        {

        User::Leave( KErrArgument);

        }

    iEngine->SetCspIdentifier( aCspId );

    IncreaseOpId( );

    iCommand->SetParametersL( aCspId.Sap(), aCspId.UserId(), aPsw, aClientId,

        aAP,  aKey1, aKey2 );   

    iCommand->StartRunL( iOpId, EImpsServWVLogin);

    SendReceive( EImpsServWVLogin, 

        TIpcArgs( &iCommand->iMessagePtr, iOpId), iCommand->iStatus );

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log(_L("RImpsAccessClient2::LoginL opId=%d"), iOpId);

#endif 

	// store the operation id

	// and set variable to false

    iLoginOpId = iOpId;

    iLoginCancelled = EFalse; 

    return iOpId;

    }

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

// RImpsAccessClient2::ReactiveLoginL()

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

EXPORT_C TInt RImpsAccessClient2::ReactiveLoginL( TImpsCspIdentifier aCspId,

                              const TDesC& aPsw,

                              const TDesC& aClientId,

                              TUint32 aAP,

                              const TDesC* aKey1,

                              const TDesC* aKey2  )

    {

    if ( !iRunning ) 

        {

        User::Leave( KImpsErrorNotRegistered);

        }

    // Check length of parameters

    if ( ( aCspId.Sap().Length() > KImpsMaxSAP ) ||

         ( aPsw.Length() > KImpsMaxPwd ) ||

         ( aClientId.Length() > KImpsMaxClientId ) )

        {

        User::Leave( KErrArgument);

        }

    iEngine->SetCspIdentifier( aCspId );

    IncreaseOpId( );

    iCommand->SetParametersL( aCspId.Sap(), aCspId.UserId(), aPsw, aClientId,

        aAP,  aKey1, aKey2 );   

    iCommand->StartRunL( iOpId, EImpsServReactiveLogin);

    SendReceive( EImpsServReactiveLogin, 

        TIpcArgs( &iCommand->iMessagePtr, iOpId), iCommand->iStatus );

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log(_L("RImpsAccessClient2::ReactiveLoginL opId=%d"), iOpId);

#endif 

	// store the operation id

	// and set variable to false

    iLoginOpId = iOpId;

    iLoginCancelled = EFalse; 

    return iOpId;

    }    

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

// RImpsAccessClient2::LogoutL()

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

EXPORT_C TInt RImpsAccessClient2::LogoutL( )

    {

    if ( !iRunning ) 

        {

        User::Leave( KImpsErrorNotRegistered );

        }

    IncreaseOpId( );

    // Command does not need to know which one, force or not.

    iCommand->StartRunL( iOpId, EImpsServWVLogout );

    TImpsServRequest req = ( EImpsServWVLogout );

    // p[ 0 ] = iOpId

    SendReceive( req, TIpcArgs(iOpId), iCommand->iStatus );

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log(_L("RImpsAccessClient2::LogoutL opId=%d"), iOpId);

#endif 

    return iOpId;

    }

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

// RImpsAccessClient2::NumberOfSessionsL()

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

EXPORT_C TInt RImpsAccessClient2::NumberOfSessionsL( TImpsCspIdentifier& aCspId )

    {

    TInt myLen = aCspId.UserId().Size() + aCspId.Sap().Size();

    // some extra space for elements needed

    HBufC8* msgStream = HBufC8::NewL( myLen + 50 );

    CleanupStack::PushL( msgStream );   // << msgStream

    *msgStream = KNullDesC8;

    CDesCArrayFlat* myTempArr = new ( ELeave )CDesCArrayFlat( 2 );

    CleanupStack::PushL( myTempArr );   // << myTempArr

    TImpsPackedEntity packedMessage( msgStream );

    myTempArr->AppendL( aCspId.Sap() );

    myTempArr->AppendL( aCspId.UserId() );

    const TUint8* pS = msgStream->Ptr();

    packedMessage.DoPackArray( pS, myTempArr );

    // update the length of the buffer

    msgStream->Des().SetLength( pS-msgStream->Ptr() );

    TInt nbrOfSessions = SendReceive( EImpsServNbrSessions, TIpcArgs( msgStream) );

    myTempArr->Reset();  

    CleanupStack::PopAndDestroy( 2 );  // >> msgStream, myTempArr

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log(_L("RImpsAccessClient2::NumberOfSessionsL opId=%d"), iOpId);

#endif  

    return nbrOfSessions;

    }

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

// RImpsAccessClient2::CancelLoginL()

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

EXPORT_C void RImpsAccessClient2::CancelLoginL( TInt aCancelOpId )

    {

    if ( iLoginOpId != aCancelOpId )

    {

    	User::Leave( KErrArgument );

    }

    TInt ret = SendReceive( EImpsServCancelLogin, TIpcArgs( aCancelOpId ) );

	// set variable to true

    iLoginCancelled = ETrue; 

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log(_L("RImpsAccessClient2::CancelLoginL opId=%d ret=%d"), aCancelOpId, ret );

#endif

    }

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

// RImpsAccessClient2::CloseCspSessionsL()

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

EXPORT_C void RImpsAccessClient2::CloseCspSessionsL( )

    {

    TImpsServRequest req = ( EImpsServCloseAll );

    SendReceive( req, TIpcArgs() );

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log(_L("RImpsAccessClient2::CloseCspSessionsL") );

#endif

    }

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

// RImpsAccessClient2::DoRegister()

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

TInt RImpsAccessClient2::DoRegister(

    RImpsEng& aEngine,

    CImpsHandler2* aHandler )

    {

    return DoRegister2( aEngine, aHandler, EImpsAccessRegister2 );

    }

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

// RImpsAccessClient2::Handler

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

MImpsAccessHandler2* RImpsAccessClient2::Handler( )

   {

   return iHandlerCallBack;

   }

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

// RImpsAccessClient2::LoginOpId()

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

TInt RImpsAccessClient2::LoginOpId()

	{

	return iLoginOpId;	

	}

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

// RImpsAccessClient2::LoginCancelled()

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

TBool RImpsAccessClient2::LoginCancelled()

	{

	return iLoginCancelled;	

	}

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

// RImpsAccessClient2::CancelHandled()

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

void RImpsAccessClient2::CancelHandled()

	{

	iLoginOpId = 0;

	iLoginCancelled = EFalse;	

	}

// ================= OTHER EXPORTED FUNCTIONS ==============

//  End of File